@trillboards/api-client 0.1.3 → 0.3.0

package/dist/index.d.mts

@@ -173,6 +173,32 @@ interface HttpClientConfig {
     baseUrl: string;
     version?: string;
 }
+interface RetryOptions {
+    /** Maximum number of retry attempts after the initial call. Defaults to 6. */
+    retries?: number;
+    /** Base delay in ms for exponential backoff. Defaults to 1000. */
+    baseMs?: number;
+    /**
+     * Optional callback invoked when an attempt fails with a retryable error.
+     * `attempt` is 1-indexed (1 = first failure). Useful for observability —
+     * the CTV SDK uses this to emit `upload_error` events without coupling
+     * the retry loop to event emission.
+     */
+    onAttemptError?: (attempt: number, error: unknown) => void;
+}
+/**
+ * Wrap an async operation in retry-with-exponential-backoff.
+ *
+ * - Retries up to `retries` times on retryable errors (429, 5xx, TypeError network).
+ * - Honors `Retry-After` header on 429 responses (parsed into TrillboardsError.retryAfter).
+ * - Throws the last error after the budget is exhausted.
+ * - Permanent 4xx (auth, validation, not-found) throw immediately on first attempt.
+ *
+ * This is the SINGLE retry primitive in the SDK — every POST/PUT/DELETE is
+ * wrapped automatically by HttpClient. GET is left to the caller because
+ * idempotency assumptions vary by route.
+ */
+declare function retryWithBackoff<T>(operation: () => Promise<T>, opts?: RetryOptions): Promise<T>;
 declare class HttpClient {
     private readonly config;
     constructor(config: HttpClientConfig);
@@ -180,10 +206,33 @@ declare class HttpClient {
     get<T>(path: string, opts?: {
         params?: Record<string, unknown>;
     }): Promise<T>;
-    post<T>(path: string, body?: unknown): Promise<T>;
-    put<T>(path: string, body?: unknown): Promise<T>;
-    patch<T>(path: string, body?: unknown): Promise<T>;
-    delete<T>(path: string): Promise<T>;
+    /**
+     * POST / PUT / PATCH / DELETE auto-retry on 429 + 5xx + network TypeError
+     * via `retryWithBackoff()`. Callers can opt into observability by passing
+     * `retry.onAttemptError` to receive a callback per transient failure.
+     *
+     * The retry behavior is identical across all four methods because all of
+     * them are state-changing operations subject to the same transient-failure
+     * classes (rate limit, upstream-down, network-flap). The wire idempotency
+     * of POST vs DELETE is enforced server-side via Idempotency-Key headers,
+     * which the caller can attach via `opts.headers`.
+     */
+    post<T>(path: string, body?: unknown, opts?: {
+        retry?: RetryOptions;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    put<T>(path: string, body?: unknown, opts?: {
+        retry?: RetryOptions;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    patch<T>(path: string, body?: unknown, opts?: {
+        retry?: RetryOptions;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    delete<T>(path: string, opts?: {
+        retry?: RetryOptions;
+        headers?: Record<string, string>;
+    }): Promise<T>;
     private buildUrl;
 }
 
@@ -257,8 +306,17 @@ declare class DevicesClient {
     delete(deviceId: string): Promise<{
         success: boolean;
     }>;
-    /** Send heartbeat for a device. */
-    heartbeat(deviceId: string, body?: Record<string, unknown>): Promise<{
+    /**
+     * Send heartbeat for a device.
+     *
+     * Auto-retries on 429 + 5xx + network TypeError via the shared
+     * retryWithBackoff() helper (see http.ts). Pass `opts.retry.onAttemptError`
+     * to observe transient failures (e.g. emit an `upload_error` event from
+     * the CTV SDK without coupling the retry loop to its event emitter).
+     */
+    heartbeat(deviceId: string, body?: Record<string, unknown>, opts?: {
+        retry?: RetryOptions;
+    }): Promise<{
         success: boolean;
     }>;
 }
@@ -600,39 +658,126 @@ declare class TrillboardsError extends Error {
 }
 
 /**
- * Webhook signature verification for Trillboards Partner API webhooks.
+ * Webhook signature verification for Trillboards webhooks.
+ *
+ * Header format produced by the server (matches Stripe-style compound shape):
  *
- * Uses HMAC-SHA256 with timing-safe comparison to prevent signature
- * forgery and timing attacks.
+ *   X-Trillboards-Signature: t=<unix_seconds>,v0=<hex>,v1=<hex>
+ *   X-Trillboards-Timestamp: <unix_seconds>     // redundant; same value as t=
+ *   X-Trillboards-Event:     <event_name>
+ *   X-Trillboards-Webhook-Id: <subscription_id>
+ *
+ * Where v1 = HMAC-SHA256(secret, `${timestamp}.${payload}`)
+ *       v0 = HMAC-SHA256(secret, payload)   ← legacy body-only, emitted for back-compat
+ *
+ * `constructEvent` prefers v1 (replay-protected); falls back to v0 when v1 is
+ * absent (server in pre-migration state) or when only the legacy
+ * `sha256=<hex>` form is present.
+ *
+ * Replay protection: a configurable tolerance window (default 300s, Stripe-
+ * aligned) rejects payloads whose timestamp is too far from the verifier's
+ * clock. Adjust via the `tolerance` option.
+ *
+ * Migration note (since 0.3.0):
+ *   The 0.2.0-shape `constructEvent(payload, signatureString, secret)` is kept
+ *   as `constructEventLegacy` for one minor version. It does NOT verify the
+ *   timestamp (the 0.2.0 verifier had no access to one). Migrate to the new
+ *   call shape `constructEvent(payload, req.headers, secret)` to gain replay
+ *   protection and compound-header support.
  */
 
+interface ConstructEventOptions {
+    /** Maximum allowed age (seconds) of a signed payload. Default 300 (Stripe-aligned). */
+    tolerance?: number;
+    /** Override the verifier's current time (seconds). Tests only. */
+    nowSec?: number;
+}
+/**
+ * Headers carried by a Trillboards webhook delivery. Accepts either the
+ * canonical Node `IncomingHttpHeaders` shape (lowercase keys) or any
+ * Record<string, string|string[]> with case-insensitive lookup.
+ */
+type WebhookHeaders = Record<string, string | string[] | undefined> | {
+    [key: string]: string | string[] | undefined;
+};
+/**
+ * Parsed signature-header components.
+ */
+interface ParsedSignatureHeader {
+    /** Unix seconds from `t=` if present. */
+    timestamp?: number;
+    /** Algorithm → hex-digest map. Standard keys: `v0`, `v1`. */
+    versions: Map<string, string>;
+    /** Set when the raw input matched the legacy `sha256=<hex>` shape. */
+    legacy?: string;
+}
+/**
+ * Parse a Trillboards `X-Trillboards-Signature` header into its component
+ * algorithm-keyed digests.
+ *
+ * Accepts:
+ *   "t=<ts>,v1=<hex>"                       → canonical
+ *   "t=<ts>,v0=<hex>,v1=<hex>"              → canonical with legacy companion
+ *   "sha256=<hex>"                          → pre-migration emitter (single value)
+ *
+ * @public
+ */
+declare function parseSignatureHeader(rawSig: string): ParsedSignatureHeader;
 /**
  * Verify a webhook payload signature and parse the event.
  *
- * @param payload  - Raw request body as string or Buffer.
- * @param signature - The signature from the `X-Trillboards-Signature` header.
- * @param secret   - The webhook secret from your webhook subscription.
- * @returns The parsed WebhookEvent if signature is valid.
- * @throws TrillboardsError if the signature does not match.
+ * @param payload — raw request body (string or Buffer). Must be EXACTLY the
+ *                  bytes the server signed — do NOT re-stringify after JSON.parse.
+ * @param headers — IncomingHttpHeaders or any Record<string, string|string[]>
+ *                  produced by your HTTP framework. Case-insensitive lookup.
+ *                  For Express, pass `req.headers`. For Next.js, `req.headers`.
+ *                  Backwards-compat: a raw signature string (the 0.2.0 shape)
+ *                  is also accepted and parsed as if it were the value of
+ *                  `X-Trillboards-Signature`; in that case the verifier looks
+ *                  for the timestamp in the compound header itself, OR throws.
+ * @param secret  — webhook subscription secret (whsec_...).
+ * @param opts.tolerance — replay-window in seconds. Default 300.
+ * @returns parsed WebhookEvent if signature valid AND timestamp within tolerance.
+ * @throws TrillboardsError(authentication_error / webhook_signature_invalid)
  *
  * @example
- * ```typescript
  * import { Webhooks } from '@trillboards/api-client';
  *
- * app.post('/webhooks', (req, res) => {
- *   const event = Webhooks.constructEvent(
- *     req.body,
- *     req.headers['x-trillboards-signature'],
- *     process.env.WEBHOOK_SECRET
- *   );
- *   console.log('Received event:', event.type);
- *   res.sendStatus(200);
+ * app.post('/webhooks', express.raw({ type: 'application/json' }), (req, res) => {
+ *   try {
+ *     const event = Webhooks.constructEvent(
+ *       req.body,                              // raw Buffer or string
+ *       req.headers,                           // IncomingHttpHeaders
+ *       process.env.WEBHOOK_SECRET!,           // your subscription secret
+ *     );
+ *     console.log('Received', event.type);
+ *     res.sendStatus(200);
+ *   } catch (err) {
+ *     // TrillboardsError with code "webhook_signature_invalid"
+ *     res.sendStatus(401);
+ *   }
  * });
- * ```
  */
-declare function constructEvent(payload: string | Buffer, signature: string, secret: string): WebhookEvent;
+declare function constructEvent(payload: string | Buffer, headers: WebhookHeaders | string, secret: string, opts?: ConstructEventOptions): WebhookEvent;
+/**
+ * @deprecated since 0.3.0 — kept for one minor version for partners stuck on
+ *   the 0.2.0 call shape. Use `constructEvent(payload, req.headers, secret)`
+ *   instead — it gains replay protection and compound-header support.
+ *
+ * Reproduces the 0.2.0 verifier exactly:
+ *   HMAC-SHA256(secret, payload) compared (constant-time) against the
+ *   supplied raw-hex signature string.
+ *
+ * Does NOT verify any timestamp. The 0.2.0 SDK never had access to one and
+ * silently accepted any age of payload — that is a vulnerability this
+ * legacy shim preserves only for migration compatibility.
+ */
+declare function constructEventLegacy(payload: string | Buffer, signature: string, secret: string): WebhookEvent;
+/** Namespaced export — matches the Stripe-style API. */
 declare const Webhooks: {
     constructEvent: typeof constructEvent;
+    constructEventLegacy: typeof constructEventLegacy;
+    parseSignatureHeader: typeof parseSignatureHeader;
 };
 
 /**
@@ -641,6 +786,389 @@ declare const Webhooks: {
  */
 declare const VERSION = "0.1.3";
 
-declare const generatedTypes: {};
+type BleScanResultData = {
+    appleContinuitySubtype?: number | null;
+    deviceType?: number | null;
+    ibeaconMajor?: number | null;
+    ibeaconMinor?: number | null;
+    ibeaconUuid?: string | null;
+    manufacturerCompanyId?: number | null;
+    rawAddress: string;
+    rssi: number;
+    serviceUuids?: Array<string> | null;
+    stableManufacturerPayloadHex?: string | null;
+    txPowerDbm?: number | null;
+    [key: string]: unknown;
+};
+type DeviceCapabilityPayload = {
+    agentType?: string | null;
+    agentVersion?: string | null;
+    audienceSensing?: {
+        cameraAvailable?: boolean | null;
+        cameraCount?: number | null;
+        cameraHealth?: {
+            lastFailureClass?: string | null;
+            lastFailureMessage?: string | null;
+            lastFrameAtMs?: number | null;
+            retryCount?: number | null;
+            state?: string | null;
+            [key: string]: unknown;
+        } | null;
+        cameraType?: string | null;
+        microphoneAvailable?: boolean | null;
+        sensingMode?: string | null;
+        [key: string]: unknown;
+    } | null;
+    audioControl?: {
+        mute?: boolean | null;
+        volume?: boolean | null;
+        [key: string]: unknown;
+    } | null;
+    capabilitiesVersion?: number | null;
+    environmentSensors?: {
+        ambientLight?: boolean | null;
+        temperature?: boolean | null;
+        [key: string]: unknown;
+    } | null;
+    inputControl?: {
+        appSwitch?: boolean | null;
+        hdmi?: boolean | null;
+        [key: string]: unknown;
+    } | null;
+    isDeviceOwner?: boolean | null;
+    managementCapabilities?: {
+        clearCache?: boolean | null;
+        installApk?: boolean | null;
+        kioskMode?: boolean | null;
+        reboot?: boolean | null;
+        restart?: boolean | null;
+        screenshot?: boolean | null;
+        wipe?: boolean | null;
+        [key: string]: unknown;
+    } | null;
+    mlCapabilities?: {
+        availableRamMb?: number | null;
+        chipsetName?: string | null;
+        chipsetVendor?: string | null;
+        cpuAbi?: string | null;
+        densityDpi?: number | null;
+        gpuDelegateSupported?: boolean | null;
+        gpuName?: string | null;
+        hasNpu?: boolean | null;
+        maxVlmSizeMb?: number | null;
+        nnapiSupported?: boolean | null;
+        npuName?: string | null;
+        osApiLevel?: number | null;
+        recommendedModelTier?: string | null;
+        screenHeightPx?: number | null;
+        screenWidthPx?: number | null;
+        totalRamMb?: number | null;
+        [key: string]: unknown;
+    } | null;
+    powerControl?: {
+        cec?: boolean | null;
+        softBlackout?: boolean | null;
+        wol?: boolean | null;
+        [key: string]: unknown;
+    } | null;
+    wifiCsiSensing?: {
+        csiAvailable?: boolean | null;
+        csiHardwareType?: string | null;
+        csiNodeCount?: number | null;
+        [key: string]: unknown;
+    } | null;
+    [key: string]: unknown;
+};
+type HttpProbeResult = {
+    host: string;
+    port?: number | null;
+    server?: string | null;
+    [key: string]: unknown;
+};
+type MdnsNetworkDevice = {
+    host?: string | null;
+    instanceName: string;
+    mdnsModel?: string | null;
+    mdnsSoftwareVersion?: string | null;
+    mdnsVendor?: string | null;
+    port?: number | null;
+    serviceType: string;
+    [key: string]: unknown;
+};
+type PartnerAdDeliveryProfile = {
+    android_api_level?: number | null;
+    auto_recovery_enabled?: boolean;
+    ima_integration?: "android_native" | "html5_webview" | "disabled" | "unknown";
+    mode?: "ima_sdk" | "vast_fallback";
+    notes?: Array<string>;
+    reason?: string;
+    webview_chromium_major?: number | null;
+};
+/**
+ * Heartbeat payload from agent-core / agent-core-lite Android partner
+ * SDKs. Only includes fields verified populated in production
+ * `signal_observations` (last 30 days). Stub fields wired in Kotlin but
+ * never observed in CH are intentionally excluded; re-add only after
+ * telemetry confirms >1% population over 7 days.
+ *
+ */
+type PartnerDeviceHeartbeatBody = {
+    advertisingId?: string | null;
+    advertisingIdType?: "gaid" | "idfa" | null | null;
+    bleDeviceCount?: number;
+    capabilities?: DeviceCapabilityPayload;
+    discoveredNetworkDevices?: Array<MdnsNetworkDevice> | null;
+    fingerprint?: string;
+    gatewayIpHash?: string | null;
+    httpProbes?: Array<HttpProbeResult> | null;
+    limitAdTracking?: boolean | null;
+    metadata?: Record<string, unknown>;
+    /** Capped at 50 devices (RSSI-sorted, strongest first). */
+    nearbyBleDevices?: Array<BleScanResultData> | null;
+    nearbyWifiNetworks?: Array<WifiScanResult> | null;
+    networkDeviceCount?: number;
+    /** Heartbeat schema version (1=baseline, 2=nativeSensorSnapshot) */
+    schemaVersion?: number;
+    screenId?: string | null;
+    /** Per-source skip-reason counter map. Shape `{source: {reason: count}}`. */
+    skipReasonCounts?: Record<string, Record<string, number>>;
+    ssdpDevices?: Array<SsdpDeviceInfo> | null;
+    status?: string;
+    wifiBssidHash?: string | null;
+    wifiEnvironment?: WifiEnvironmentSnapshot;
+    wifiNetworkCount?: number;
+    wifiSsidHash?: string | null;
+    [key: string]: unknown;
+};
+type PartnerHeartbeatCommand = {
+    /** Command normalized for partner SDK compatibility. */
+    command?: string;
+    id?: string;
+    payload?: Record<string, unknown>;
+    queued_at?: string;
+};
+type PartnerHeartbeatData = {
+    ad_delivery_profile?: PartnerAdDeliveryProfile;
+    commands?: Array<PartnerHeartbeatCommand>;
+    last_seen_at?: string;
+    status?: "online" | "offline";
+};
+type PartnerHeartbeatMeasurementMetadata = {
+    ageSeconds?: number | null;
+    cachedAt?: string | null;
+    receivedAt?: string | null;
+    source?: "redis_twin" | "pg_fallback" | "unknown";
+    [key: string]: unknown;
+};
+type PartnerHeartbeatQueryData = {
+    adDeliveryProfile?: PartnerAdDeliveryProfile;
+    deviceId: string;
+    lastHeartbeatAt?: string | null;
+    measurementMetadata?: PartnerHeartbeatMeasurementMetadata;
+    stalenessSeconds?: number | null;
+    telemetry?: PartnerSafeHeartbeatTelemetry;
+    [key: string]: unknown;
+};
+type PartnerHeartbeatQueryResponse = {
+    data?: PartnerHeartbeatQueryData;
+    success?: boolean;
+};
+/**
+ * Optional heartbeat payload. Nested telemetry objects are preferred; legacy flat keys
+ * are still accepted for backward compatibility.
+ *
+ */
+type PartnerHeartbeatRequest = {
+    ad?: {
+        last_vast_request_at?: string;
+        last_vast_response_at?: string;
+        proof_of_play_enabled?: boolean;
+    };
+    agent_status?: string;
+    agent_version?: string;
+    android_api_level?: number;
+    brightness?: number;
+    desugaring_enabled?: boolean;
+    device?: {
+        android_api_level?: number;
+        make?: string;
+        model?: string;
+        os?: string;
+        osv?: string;
+        webview_chromium_major?: number;
+    };
+    ima_integration?: "android_native" | "html5_webview" | "disabled" | "unknown";
+    ima_sdk_version?: string;
+    ima_support_reason?: string;
+    ima_supported?: boolean;
+    input_source?: string;
+    last_ima_error_code?: number;
+    last_vast_error_code?: number;
+    last_vast_request_at?: string;
+    last_vast_response_at?: string;
+    /** Alternate namespace for telemetry keys (legacy support). */
+    metadata?: Record<string, unknown>;
+    muted?: boolean;
+    network?: {
+        bandwidthMbps?: number;
+        connectionType?: string;
+        downlinkMbps?: number;
+        effectiveType?: string;
+        latencyRtt?: number;
+        rtt?: number;
+        saveData?: boolean;
+    };
+    network_strength_dbm?: number;
+    power_state?: "on" | "standby" | "off" | "unknown";
+    proof_of_play_enabled?: boolean;
+    sdk?: {
+        android_api_level?: number;
+        desugaring_enabled?: boolean;
+        ima_integration?: "android_native" | "html5_webview" | "disabled" | "unknown";
+        ima_sdk_version?: string;
+        ima_supported?: boolean;
+        version?: string;
+        webview_chromium_major?: number;
+    };
+    sdk_version?: string;
+    telemetry?: PartnerHeartbeatTelemetry;
+    temperature_c?: number;
+    uptime_seconds?: number;
+    volume?: number;
+    webview_chromium_major?: number;
+};
+type PartnerHeartbeatResponse = {
+    data?: PartnerHeartbeatData;
+    success?: boolean;
+};
+type PartnerHeartbeatTelemetry = {
+    agentStatus?: string;
+    agentVersion?: string;
+    android_api_level?: number;
+    bandwidthMbps?: number;
+    brightness?: number;
+    connectionType?: string;
+    desugaring_enabled?: boolean;
+    downlinkMbps?: number;
+    ima_integration?: "android_native" | "html5_webview" | "disabled" | "unknown";
+    ima_sdk_version?: string;
+    ima_support_reason?: string;
+    ima_supported?: boolean;
+    inputSource?: string;
+    last_ima_error_code?: number;
+    last_vast_error_code?: number;
+    last_vast_request_at?: string;
+    last_vast_response_at?: string;
+    latencyRtt?: number;
+    make?: string;
+    model?: string;
+    muted?: boolean;
+    networkConnectionType?: string;
+    networkEffectiveType?: string;
+    networkStrengthDbm?: number;
+    os?: string;
+    osVersion?: string;
+    osv?: string;
+    powerState?: "on" | "standby" | "off" | "unknown";
+    proof_of_play_enabled?: boolean;
+    rtt?: number;
+    saveData?: boolean;
+    temperatureC?: number;
+    uptimeSeconds?: number;
+    volume?: number;
+    webview_chromium_major?: number;
+    [key: string]: unknown;
+};
+/**
+ * Partner-safe subset of device telemetry. Strips MDM compliance,
+ * Vertex embeddings, identity-correction internals, partner identifiers,
+ * and Mongo `_id` so partners only see what they need to decide
+ * whether a device is healthy enough to receive ads.
+ *
+ */
+type PartnerSafeHeartbeatTelemetry = {
+    agentStatus?: string | null;
+    agentVersion?: string | null;
+    bandwidthMbps?: number | null;
+    brightness?: number | null;
+    connectionType?: string | null;
+    consecutiveAdFailures?: number | null;
+    effectiveType?: string | null;
+    latencyRtt?: number | null;
+    make?: string | null;
+    model?: string | null;
+    muted?: boolean | null;
+    networkStrengthDbm?: number | null;
+    onlineStatus?: "online" | "offline" | "standby" | "unknown" | null;
+    os?: string | null;
+    osv?: string | null;
+    powerState?: string | null;
+    temperatureC?: number | null;
+    ua?: string | null;
+    uptimeSeconds?: number | null;
+    visibilityState?: string | null;
+    volume?: number | null;
+    [key: string]: unknown;
+};
+type SsdpDeviceInfo = {
+    friendlyName?: string | null;
+    location: string;
+    manufacturer?: string | null;
+    modelName?: string | null;
+    server?: string | null;
+    st: string;
+    udn?: string | null;
+    [key: string]: unknown;
+};
+type WifiEnvironmentSnapshot = {
+    channelCongestionRatio?: number | null;
+    connectedChannelWidthMhz?: number | null;
+    connectedFrequencyMhz?: number | null;
+    connectedLinkSpeedMbps?: number | null;
+    connectedSignalDbm?: number | null;
+    frequencyBand?: string | null;
+    medianSignalDbm?: number | null;
+    networkCount?: number | null;
+    rssiVariance?: number | null;
+    scanTimestampMs?: number | null;
+    signalSpreadDbm?: number | null;
+    uniqueBssidCount?: number | null;
+    [key: string]: unknown;
+} | null;
+type WifiScanResult = {
+    channelWidthMhz?: number | null;
+    frequencyMhz: number;
+    rawBssid: string;
+    signalStrengthDbm: number;
+    [key: string]: unknown;
+};
+/**
+ * Read live device heartbeat state
+ * GET /device/{deviceId}/heartbeat
+ */
+interface getDeviceHeartbeatOperation {
+    readonly path: "/device/{deviceId}/heartbeat";
+    readonly method: "GET";
+    request: never;
+    response: PartnerHeartbeatQueryResponse;
+}
+/**
+ * Device heartbeat
+ * POST /device/{deviceId}/heartbeat
+ */
+interface heartbeatOperation {
+    readonly path: "/device/{deviceId}/heartbeat";
+    readonly method: "POST";
+    request: PartnerHeartbeatRequest | PartnerDeviceHeartbeatBody;
+    response: PartnerHeartbeatResponse;
+}
+declare const generatedTypes: {
+    readonly schemaCount: 71;
+    readonly operationCount: 175;
+    readonly schemas: readonly ["Ad", "AdSettings", "AudienceAnalyticsResponse", "AudienceAttentionPrediction", "AudienceExportResponse", "AudienceLoyaltyFeaturesRow", "AudienceMetricsResponse", "AudienceSegment", "AudienceSocialAttention", "BatchResult", "BleScanResultData", "ChangelogEntry", "ChangelogResponse", "ContentPreferencesInput", "ContentPreferencesResponse", "ContentPreset", "DashboardResponse", "DataExportSummaryResponse", "DemographicsResponse", "Device", "DeviceCapabilityPayload", "DeviceSummary", "DisplaySettingsInput", "DisplaySettingsResponse", "EarningsBreakdownResponse", "EarningsResponse", "Error", "HeaderBiddingSettings", "HttpProbeResult", "MdnsNetworkDevice", "Pagination", "Partner", "PartnerAdDeliveryProfile", "PartnerDefaultStream", "PartnerDefaultStreamCreate", "PartnerDefaultStreamUpdate", "PartnerDeviceHeartbeatBody", "PartnerHeartbeatCommand", "PartnerHeartbeatData", "PartnerHeartbeatMeasurementMetadata", "PartnerHeartbeatQueryData", "PartnerHeartbeatQueryResponse", "PartnerHeartbeatRequest", "PartnerHeartbeatResponse", "PartnerHeartbeatTelemetry", "PartnerLBarContent", "PartnerLBarDisplayPreferences", "PartnerLBarSettings", "PartnerSafeHeartbeatTelemetry", "PartnerSelfPromoAd", "PartnerSelfPromoCreate", "PartnerSelfPromoPlacement", "PartnerStats", "PayoutResponse", "PlaygroundResult", "PlaygroundValidationError", "ProgrammaticSettingsInput", "ProgrammaticSettingsResponse", "RequestMetadataResponse", "RolePermissions", "SDKConfig", "ScreenAnalyticsResponse", "SsdpDeviceInfo", "TeamInviteResponse", "TeamMember", "Transaction", "Webhook", "WebhookDelivery", "WebhookEvent", "WifiEnvironmentSnapshot", "WifiScanResult"];
+    readonly operations: readonly ["listPartnerSelfPromoAds", "createPartnerSelfPromoAd", "listPartnerSelfPromoPlacements", "schedulePartnerSelfPromo", "createPartnerSelfPromoUpload", "disableSelfPromoAd", "registerAgent", "getAnalytics", "getAudienceContinuity", "getAudienceProfile", "getBleSummary", "getContentPerformance", "searchCreativeCatalog", "getCreativeScenes", "getCrossScreenFlow", "getPartnerAnalyticsDashboard", "getDeviceSuiteSignature", "exportPartnerAnalytics", "exportPartnerAdsByDay", "getFleetHourly", "getHaloFunnel", "getLoyaltyClock", "getNetworkSummary", "getNetworkTrend", "getProximitySummary", "getRevenueAttentionCorrelation", "getSceneFeed", "getSceneIntelligence", "rotateApiKey", "getAudienceAnalytics", "exportAudienceData", "getAudienceHeatmap", "getLiveAudience", "getLookalikeScreens", "predictScreenAudience", "getResolvedHouseholdReach", "listAudienceSegments", "createAudienceSegment", "deleteAudienceSegment", "getAudienceSegment", "updateAudienceSegment", "matchAudienceSegment", "estimateSegmentReach", "generateSegmentVastTag", "getAudienceStats", "cancelBillingSubscription", "purchaseCredits", "createCreditCheckout", "listBillingPlans", "setupBilling", "createBillingSubscription", "getBillingSubscription", "getBillingUsage", "getUsageSummary", "stripeWebhookCallback", "getConnectDashboard", "getConnectEarningsChart", "getConnectScreenHealth", "listContentPresets", "getContentPreset", "getDashboard", "exportProximityGraphEdges", "getDataExportSummary", "exportDataset", "getGeohashAudiencePanel", "registerDevice", "deleteDevice", "getDevice", "updateDevice", "getAdsForDevice", "ackDeviceCommand", "getDeviceHeartbeat", "heartbeat", "recordProgrammaticEvent", "listDevices", "registerDevicesBatch", "batchUpdateDeviceOrientation", "partnerDocsBrowser", "getEarnings", "getEarningsBreakdown", "requestPayout", "getTransactions", "getActiveSSEConnections", "subscribeToEvents", "getFleetAnalytics", "pushFleetCommand", "getFleetOverview", "updateFleetSettings", "recordImpressionGet", "recordImpressionPost", "recordImpressionsBatch", "getPartnerInfo", "listIntentCategories", "getIntentCategory", "getIntentPricing", "getMeasurementMethodology", "getNetworkConfig", "patchNetworkConfig", "updateNetworkConfig", "getNetworkTrends", "partnerPing", "partnerPingAuth", "getPricing", "quickStart", "registerPartner", "generateSandboxEvent", "resetSandbox", "createSandboxScreen", "getSandboxStatus", "getScreenAudienceSegments", "batchUpdateContentPreferences", "batchUpdateDisplaySettings", "batchUpdateProgrammaticSettings", "resolvePartnerScreen", "getScreenAnalytics", "getPartnerScreenAtmosphere", "getPartnerScreenIntelligence", "getPartnerScreenTasteProfile", "getPartnerScreenTraffic", "getPartnerScreenVAS", "applyContentPreset", "getAudienceMetrics", "getContentPreferences", "patchContentPreferences", "updateContentPreferences", "listPartnerDefaultStreams", "createPartnerDefaultStream", "createPartnerDefaultStreamImages", "reorderPartnerDefaultStreams", "createPartnerDefaultStreamUpload", "deletePartnerDefaultStream", "updatePartnerDefaultStream", "getScreenDemographics", "getDisplaySettings", "patchDisplaySettings", "updateDisplaySettings", "getPartnerLBarSettings", "updatePartnerLBarSettings", "updatePartnerLBarLiveUpdates", "getProgrammaticSettings", "patchProgrammaticSettings", "updateProgrammaticSettings", "createStripeConnectAccount", "getStripeLoginLink", "getStripeOnboardingLink", "requestStripePayout", "getStripePayoutHistory", "getStripeAccountStatus", "handleStripeWebhook", "listTeamMembers", "acceptInvitation", "inviteTeamMember", "getInvitationByToken", "resendInvitation", "removeTeamMember", "changeTeamMemberRole", "getTrackingPublicKey", "recordTrackingBatch", "getUsageSummary__get__usage", "getUsageDashboard", "getRateLimitStatus", "queryChangelog", "playgroundDryRun", "getRequestMetadata", "getVastConfig", "getVenuesNearby", "getVenueAtmosphere", "getVenueTraffic", "getVenueIntelligence", "listWebhooks", "createWebhook", "deleteWebhook", "updateWebhook", "getWebhookDeliveries", "testWebhook"];
+};
+type GeneratedSchemaName = (typeof generatedTypes.schemas)[number];
+type GeneratedOperationName = (typeof generatedTypes.operations)[number];
 
-export { AnalyticsClient, type AnalyticsData, type ApiErrorType, AudienceClient, type AudienceData, BillingClient, type BillingInfo, type ClientOptions, DataClient, type Device, DevicesClient, EarningsClient, type EarningsData, type ErrorDetail, type ErrorEntry, type ErrorResponseBody, ErrorsClient, FleetClient, type FleetCommand, type Impression, ImpressionsClient, type ListResponse, type RequestOptions, type Screen, ScreensClient, TrillboardsClient, TrillboardsError, type TrillboardsErrorOptions, VERSION, type Webhook, type WebhookEvent, Webhooks, WebhooksClient, constructEvent, generatedTypes };
+export { AnalyticsClient, type AnalyticsData, type ApiErrorType, AudienceClient, type AudienceData, BillingClient, type BillingInfo, type BleScanResultData, type ClientOptions, type ConstructEventOptions, DataClient, type Device, type DeviceCapabilityPayload, DevicesClient, EarningsClient, type EarningsData, type ErrorDetail, type ErrorEntry, type ErrorResponseBody, ErrorsClient, FleetClient, type FleetCommand, type GeneratedOperationName, type GeneratedSchemaName, type HttpProbeResult, type Impression, ImpressionsClient, type ListResponse, type MdnsNetworkDevice, type ParsedSignatureHeader, type PartnerAdDeliveryProfile, type PartnerDeviceHeartbeatBody, type PartnerHeartbeatMeasurementMetadata, type PartnerHeartbeatQueryData, type PartnerHeartbeatQueryResponse, type PartnerHeartbeatRequest, type PartnerHeartbeatResponse, type PartnerSafeHeartbeatTelemetry, type RequestOptions, type RetryOptions, type Screen, ScreensClient, type SsdpDeviceInfo, TrillboardsClient, TrillboardsError, type TrillboardsErrorOptions, VERSION, type Webhook, type WebhookEvent, type WebhookHeaders, Webhooks, WebhooksClient, type WifiEnvironmentSnapshot, type WifiScanResult, constructEvent, constructEventLegacy, generatedTypes, type getDeviceHeartbeatOperation, type heartbeatOperation, parseSignatureHeader, retryWithBackoff };