crowdplaysdk 0.2.3

package/ios/CrowdPlayRNVideoView.swift

@@ -0,0 +1,76 @@
+import CrowdPlaySDK
+#if canImport(React)
+import React
+#endif
+import UIKit
+
+/// Native video tile hosted in the RN layout. Resolves the requested
+/// participant's track from the shared engine on a short poll — idempotent
+/// and reconnect-proof, and the video itself never touches JavaScript.
+final class CrowdPlayRNVideoView: UIView {
+    private let videoView = VideoView()
+    private var resolveTimer: Timer?
+
+    @objc var participant: NSString = "" {
+        didSet { resolveTrack() }
+    }
+
+    @objc var mirror: Bool = false {
+        didSet { videoView.mirrorMode = mirror ? .mirror : .off }
+    }
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        videoView.layoutMode = .fill
+        addSubview(videoView)
+        resolveTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] _ in
+            self?.resolveTrack()
+        }
+    }
+
+    @available(*, unavailable)
+    required init?(coder _: NSCoder) { fatalError("not supported") }
+
+    deinit {
+        resolveTimer?.invalidate()
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        videoView.frame = bounds
+    }
+
+    override func willMove(toWindow newWindow: UIWindow?) {
+        super.willMove(toWindow: newWindow)
+        if newWindow == nil {
+            resolveTimer?.invalidate()
+            resolveTimer = nil
+            videoView.track = nil
+        }
+    }
+
+    private func resolveTrack() {
+        let requested = participant as String
+        let room = CrowdPlayRNCore.shared.engine.room
+        let track: VideoTrack?
+        if requested == "local" || requested.isEmpty {
+            track = room.localParticipant.firstCameraVideoTrack
+        } else {
+            track = room.remoteParticipants.values
+                .first { $0.identity?.stringValue == requested }?
+                .firstCameraVideoTrack
+        }
+        if videoView.track?.sid != track?.sid || (videoView.track == nil) != (track == nil) {
+            videoView.track = track
+        }
+    }
+}
+
+@objc(CrowdPlayVideoViewManager)
+public final class CrowdPlayVideoViewManager: RCTViewManager {
+    public override static func requiresMainQueueSetup() -> Bool { true }
+
+    public override func view() -> UIView! {
+        CrowdPlayRNVideoView()
+    }
+}

package/ios/CrowdPlayReactNative.m

@@ -0,0 +1,42 @@
+// Objective-C registration for the CrowdPlay RN bridge. Add this file AND the
+// two Swift files to your app target (they compile alongside your app, with
+// CrowdPlaySDK coming from the Swift package — see the package README).
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE (CrowdPlayReactNative, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(configure : (NSDictionary *)config)
+RCT_EXTERN_METHOD(consentText : (RCTPromiseResolveBlock)resolve
+                  rejecter : (RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(join : (NSString *)displayName
+                  roomCode : (NSString *)roomCode
+                  consentGrantedAtMs : (nonnull NSNumber *)consentGrantedAtMs
+                  resolver : (RCTPromiseResolveBlock)resolve
+                  rejecter : (RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(leave : (RCTPromiseResolveBlock)resolve
+                  rejecter : (RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setMicMuted : (BOOL)muted
+                  resolver : (RCTPromiseResolveBlock)resolve
+                  rejecter : (RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setCameraEnabled : (BOOL)enabled
+                  resolver : (RCTPromiseResolveBlock)resolve
+                  rejecter : (RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setAudioOutput : (NSString *)output)
+RCT_EXTERN_METHOD(retryRecording)
+RCT_EXTERN_METHOD(retryUploads)
+RCT_EXTERN_METHOD(warmUp)
+RCT_EXTERN_METHOD(snapshot : (RCTPromiseResolveBlock)resolve
+                  rejecter : (RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(doctor : (RCTPromiseResolveBlock)resolve
+                  rejecter : (RCTPromiseRejectBlock)reject)
+
+@end
+
+@interface RCT_EXTERN_MODULE (CrowdPlayVideoViewManager, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(participant, NSString)
+RCT_EXPORT_VIEW_PROPERTY(mirror, BOOL)
+
+@end

package/ios/wire.rb

@@ -0,0 +1,81 @@
+# Wires crowdplaysdk into an iOS app project. Run from your app's
+# ios/ directory after `pod install`:
+#
+#   ruby node_modules/crowdplaysdk/ios/wire.rb <YourProjectName>
+#
+# What it does (idempotent — safe to re-run):
+#   1. adds the CrowdPlaySDK Swift package (compiled engine) to the project
+#   2. copies the three bridge files into your app group + target
+#   3. creates/points the Swift bridging header at the React headers
+#
+# Requires the `xcodeproj` gem (ships with CocoaPods installs; otherwise
+# `gem install xcodeproj`).
+
+require 'fileutils'
+require 'xcodeproj'
+
+SDK_URL = 'https://github.com/symbiateam/crowdplaysdk'
+SDK_VERSION = '0.2.3'
+BRIDGE_FILES = ['CrowdPlayRNModule.swift', 'CrowdPlayRNVideoView.swift', 'CrowdPlayReactNative.m'].freeze
+
+project_name = ARGV[0] or abort 'usage: ruby wire.rb <YourProjectName>'
+project_path = "#{project_name}.xcodeproj"
+abort "#{project_path} not found — run from your app's ios/ directory" unless File.exist?(project_path)
+
+package_dir = File.expand_path(File.dirname(__FILE__))
+project = Xcodeproj::Project.open(project_path)
+target = project.targets.find { |t| t.name == project_name } ||
+         project.targets.find { |t| t.product_type == 'com.apple.product-type.application' }
+abort 'no application target found' unless target
+
+# 1. CrowdPlaySDK Swift package (skip when already present).
+unless project.root_object.package_references.any? { |r| r.respond_to?(:repositoryURL) && r.repositoryURL == SDK_URL }
+  pkg = project.new(Xcodeproj::Project::Object::XCRemoteSwiftPackageReference)
+  pkg.repositoryURL = SDK_URL
+  pkg.requirement = { 'kind' => 'exactVersion', 'version' => SDK_VERSION }
+  project.root_object.package_references << pkg
+  dep = project.new(Xcodeproj::Project::Object::XCSwiftPackageProductDependency)
+  dep.package = pkg
+  dep.product_name = 'CrowdPlaySDK'
+  target.package_product_dependencies << dep
+  puts "+ CrowdPlaySDK package #{SDK_VERSION}"
+end
+
+# 2. Bridge files into the app group + target.
+group = project.main_group[project_name] || project.main_group
+group_dir = group.real_path.to_s
+BRIDGE_FILES.each do |name|
+  destination = File.join(group_dir, name)
+  FileUtils.cp(File.join(package_dir, name), destination)
+  next if group.files.any? { |f| f.display_name == name }
+
+  ref = group.new_reference(name)
+  target.add_file_references([ref])
+  puts "+ #{name}"
+end
+
+# 3. Bridging header (created only when the target has none).
+target.build_configurations.each do |config|
+  config.build_settings['SWIFT_VERSION'] ||= '5.0'
+  # CrowdPlaySDK requires iOS 17; RN templates default far lower. Only the APP
+  # target is raised — pods keep their own targets, which is fine.
+  current = config.build_settings['IPHONEOS_DEPLOYMENT_TARGET']
+  if current.nil? || current.to_f < 17.0
+    config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '17.0'
+  end
+  next if config.build_settings['SWIFT_OBJC_BRIDGING_HEADER']
+
+  header_name = "#{project_name}-Bridging-Header.h"
+  header_path = File.join(group_dir, header_name)
+  unless File.exist?(header_path)
+    File.write(header_path, <<~OBJC)
+      #import <React/RCTBridgeModule.h>
+      #import <React/RCTEventEmitter.h>
+      #import <React/RCTViewManager.h>
+    OBJC
+  end
+  config.build_settings['SWIFT_OBJC_BRIDGING_HEADER'] = "#{project_name}/#{header_name}"
+end
+
+project.save
+puts 'wired. Open the workspace and build, or: xcodebuild -workspace …'

package/lib/ConsentScreen.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Drop-in consent screen. Shows CrowdPlay's locked consent wording (fetched from
+ * the native SDK so it can never drift from what the manifest records), a
+ * switch, and a continue button that only enables once the participant
+ * agrees. Yields the ConsentGrant that join() requires.
+ *
+ *     <CrowdPlayConsentScreen onConsent={(grant) => joinWith(grant)} />
+ *
+ * Apps with their own consent UI can skip this component: render
+ * CrowdPlay.consentText() verbatim and construct { grantedAtMs: Date.now() } at
+ * the moment of agreement.
+ */
+import React from 'react';
+import { type ConsentGrant } from './index';
+export interface CrowdPlayConsentScreenProps {
+    onConsent: (grant: ConsentGrant) => void;
+    /** Optional style overrides for the outer container. */
+    style?: object;
+}
+export declare function CrowdPlayConsentScreen({ onConsent, style }: CrowdPlayConsentScreenProps): React.JSX.Element;

package/lib/ConsentScreen.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Drop-in consent screen. Shows CrowdPlay's locked consent wording (fetched from
+ * the native SDK so it can never drift from what the manifest records), a
+ * switch, and a continue button that only enables once the participant
+ * agrees. Yields the ConsentGrant that join() requires.
+ *
+ *     <CrowdPlayConsentScreen onConsent={(grant) => joinWith(grant)} />
+ *
+ * Apps with their own consent UI can skip this component: render
+ * CrowdPlay.consentText() verbatim and construct { grantedAtMs: Date.now() } at
+ * the moment of agreement.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrowdPlayConsentScreen = CrowdPlayConsentScreen;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const index_1 = __importDefault(require("./index"));
+function CrowdPlayConsentScreen({ onConsent, style }) {
+    const [text, setText] = (0, react_1.useState)(null);
+    const [agreed, setAgreed] = (0, react_1.useState)(false);
+    const [agreedAtMs, setAgreedAtMs] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        index_1.default.consentText()
+            .then((wording) => {
+            if (!cancelled)
+                setText(wording);
+        })
+            .catch(() => {
+            if (!cancelled)
+                setText('Consent text unavailable — check that CrowdPlay.configure() ran and the native module is installed.');
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    return (<react_native_1.View style={[styles.container, style]}>
+      <react_native_1.Text style={styles.title}>Recording consent</react_native_1.Text>
+      {text === null ? (<react_native_1.ActivityIndicator />) : (<react_native_1.Text style={styles.body}>{text}</react_native_1.Text>)}
+      <react_native_1.View style={styles.row}>
+        <react_native_1.Switch value={agreed} onValueChange={(value) => {
+            setAgreed(value);
+            setAgreedAtMs(value ? Date.now() : null);
+        }}/>
+        <react_native_1.Text style={styles.agree}>I agree</react_native_1.Text>
+      </react_native_1.View>
+      <react_native_1.Text style={styles.note}>
+        Recording starts automatically when you join, and ends when you leave.
+      </react_native_1.Text>
+      <react_native_1.Pressable accessibilityRole="button" disabled={!agreed || agreedAtMs === null} onPress={() => {
+            if (agreedAtMs !== null)
+                onConsent({ grantedAtMs: agreedAtMs });
+        }} style={({ pressed }) => [
+            styles.button,
+            (!agreed || agreedAtMs === null) && styles.buttonDisabled,
+            pressed && styles.buttonPressed,
+        ]}>
+        <react_native_1.Text style={styles.buttonLabel}>Continue</react_native_1.Text>
+      </react_native_1.Pressable>
+    </react_native_1.View>);
+}
+const styles = react_native_1.StyleSheet.create({
+    container: { padding: 20, gap: 16 },
+    title: { fontSize: 20, fontWeight: '700' },
+    body: { fontSize: 15, lineHeight: 21 },
+    row: { flexDirection: 'row', alignItems: 'center', gap: 10 },
+    agree: { fontSize: 15 },
+    note: { fontSize: 12, opacity: 0.6 },
+    button: { backgroundColor: '#1f6feb', borderRadius: 8, paddingVertical: 12, alignItems: 'center' },
+    buttonDisabled: { opacity: 0.4 },
+    buttonPressed: { opacity: 0.8 },
+    buttonLabel: { color: 'white', fontSize: 16, fontWeight: '600' },
+});

package/lib/VideoView.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Native video tile. Renders the LOCAL camera preview or a REMOTE
+ * participant's live video (identified by the `identity` from the
+ * `participants` event). The video never touches JavaScript — this is a
+ * native LiveKit view hosted in your RN layout.
+ *
+ *     <CrowdPlayVideoView participant="local" style={{ width: 120, height: 160 }} />
+ *     {participants.map(p => (
+ *       <CrowdPlayVideoView key={p.identity} participant={p.identity} style={styles.tile} />
+ *     ))}
+ */
+import React from 'react';
+import { type ViewProps } from 'react-native';
+export interface CrowdPlayVideoViewProps extends ViewProps {
+    /** "local" for the self-view, or a remote participant's identity. */
+    participant: string;
+    /** Mirror the image (typical for the self-view). Default: true for
+     * "local", false otherwise. */
+    mirror?: boolean;
+}
+export declare function CrowdPlayVideoView(props: CrowdPlayVideoViewProps): React.JSX.Element;

package/lib/VideoView.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Native video tile. Renders the LOCAL camera preview or a REMOTE
+ * participant's live video (identified by the `identity` from the
+ * `participants` event). The video never touches JavaScript — this is a
+ * native LiveKit view hosted in your RN layout.
+ *
+ *     <CrowdPlayVideoView participant="local" style={{ width: 120, height: 160 }} />
+ *     {participants.map(p => (
+ *       <CrowdPlayVideoView key={p.identity} participant={p.identity} style={styles.tile} />
+ *     ))}
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrowdPlayVideoView = CrowdPlayVideoView;
+const react_1 = __importDefault(require("react"));
+const react_native_1 = require("react-native");
+const NativeCrowdPlayVideoView = (0, react_native_1.requireNativeComponent)('CrowdPlayVideoView');
+function CrowdPlayVideoView(props) {
+    const { participant, mirror, ...rest } = props;
+    return (<NativeCrowdPlayVideoView participant={participant} mirror={mirror ?? participant === 'local'} {...rest}/>);
+}

package/lib/index.d.ts

@@ -0,0 +1,189 @@
+/**
+ * crowdplaysdk — CrowdPlay's lossless capture SDK for React Native (iOS).
+ *
+ * The recording engine is 100% native (CrowdPlaySDK): studio-grade audio
+ * (48 kHz / 24-bit, unprocessed) + 1080p30 video captured locally during a
+ * live call, clock-synced across participants, uploaded to CrowdPlay with
+ * retries and crash recovery. **No media ever crosses the JS bridge** —
+ * only control calls and state events — so recording quality is identical
+ * to a fully native app.
+ *
+ *     import CrowdPlay, { CrowdPlayConsentScreen, CrowdPlayVideoView } from 'crowdplaysdk';
+ *
+ *     CrowdPlay.configure({ serverUrl: '…', appKey: 'liva_pk_…' });
+ *     // Show CrowdPlayConsentScreen (or your own UI) → ConsentGrant
+ *     await CrowdPlay.join({ displayName: 'Sam', roomCode: 'abc', consent });
+ *     // …
+ *     await CrowdPlay.leave(); // recording stops; uploads continue automatically
+ *
+ * Consent is enforced twice: join() throws here without a grant, and the
+ * native layer requires the consent record structurally — there is no code
+ * path that records without it.
+ */
+/** Live-call (Path A) quality. The RECORDING is always 1080p30 + 24-bit WAV
+ * regardless; raising these trades upload + thermal headroom (which the
+ * recording needs on long sessions) for a prettier live picture. Values are
+ * clamped natively to a safe envelope (≤1280×720, 10–30 fps, ≤2.5 Mbps
+ * video, 16–128 kbps audio). */
+export interface CallQuality {
+    videoWidth?: number;
+    videoHeight?: number;
+    videoFps?: number;
+    videoBitrate?: number;
+    audioBitrate?: number;
+}
+export interface CrowdPlayConfig {
+    /** CrowdPlay backend base URL (https, no trailing slash). */
+    serverUrl: string;
+    /** From the CrowdPlay dashboard. Also your data-access credential. */
+    appKey: string;
+    /** Video (~2 GB/session) rides cellular too when true. Audio + metadata
+     * always upload on any network. Default false. */
+    videoUploadsOnCellular?: boolean;
+    /** Upload segments while the call records, so the post-call wait is
+     * roughly the final segment + manifests. Mid-call transfers run one at
+     * a time and pause automatically when call quality drops — the call
+     * always wins the uplink. Default true. */
+    uploadDuringCall?: boolean;
+    callQuality?: CallQuality;
+}
+/** Proof the participant agreed. Produce it with CrowdPlayConsentScreen, or —
+ * if you render your own consent UI — call CrowdPlay.consentText() to show the
+ * REQUIRED wording and construct the grant at the moment of agreement. */
+export interface ConsentGrant {
+    /** Date.now() at the moment the participant agreed. */
+    grantedAtMs: number;
+}
+export type Phase = 'idle' | 'connecting' | 'connected' | 'failed';
+export interface RecordingSnapshot {
+    /** Seconds of audio safely written so far. */
+    seconds: number;
+    segmentsClosed: number;
+    droppedSamples: number;
+    /** Live input level. Speech sits around −25…−45 dBFS. */
+    inputLevelDbfs: number;
+    /** True after 10 s of silence while unmuted — a dead/disconnected mic.
+     * Surface this loudly; it is fixable mid-call. */
+    inputSilent: boolean;
+    /** Samples at digital full scale — a too-hot mic, irreversibly clipped. */
+    fullScaleSamples: number;
+}
+export interface UploadKindProgress {
+    total: number;
+    uploaded: number;
+    failed: number;
+    bytesTotal: number;
+    bytesUploaded: number;
+}
+export interface UploadProgress {
+    sessionId: string;
+    fraction: number;
+    isComplete: boolean;
+    failed: number;
+    /** Manifests + audio: upload on any network. */
+    audio: UploadKindProgress;
+    /** Video: waits for WiFi unless videoUploadsOnCellular. */
+    video: UploadKindProgress;
+}
+export interface Participant {
+    identity: string;
+    name: string;
+}
+export interface DoctorCheck {
+    id: string;
+    passed: boolean;
+    detail: string;
+}
+export interface CrowdPlayEvents {
+    /** Connection lifecycle. `error` is set when phase === 'failed'. */
+    phase: {
+        phase: Phase;
+        error?: string;
+    };
+    /** Recording state. `error` non-null means the session is NOT being
+     * captured — show it prominently and offer retryRecording(). */
+    recording: {
+        isRecording: boolean;
+        error?: string;
+    };
+    /** Upload progress for every session with outstanding or recent work. */
+    uploads: {
+        sessions: UploadProgress[];
+        onWifi: boolean;
+    };
+    /** Remote participants (join/leave). Render a CrowdPlayVideoView per entry. */
+    participants: {
+        participants: Participant[];
+    };
+    /** Live capture warnings: audioStalled (engine down, auto-recovering),
+     * micSilent (dead mic), clipping (too-hot mic), crossTalk (loudspeaker
+     * leaking the far end into this mic), micPolicy (unexpected input). */
+    warning: {
+        kind: 'audioStalled' | 'micSilent' | 'clipping' | 'crossTalk' | 'micPolicy';
+        active: boolean;
+        message: string;
+    };
+    /** The audio output route: current device by name ("AirPods Pro",
+     * "iPhone speaker"), connected candidates, and whether headphones are
+     * attached. Drive the call screen's output menu from this (D-079). */
+    audioRoute: {
+        currentOutputName: string;
+        detectedOutputs: string[];
+        headphonesConnected: boolean;
+    };
+}
+export type CrowdPlayEventName = keyof CrowdPlayEvents;
+declare const CrowdPlay: {
+    /** Call once at app start, before anything else. Also resumes uploads
+     * interrupted by a crash, reboot or force-quit. */
+    configure(config: CrowdPlayConfig): void;
+    /** The REQUIRED consent wording (owned by CrowdPlay, versioned by hash). Show
+     * it verbatim if you build your own consent UI. */
+    consentText(): Promise<string>;
+    /** Pre-warms CrowdPlay's backend so joining is fast. Call from your join/lobby
+     * screen. Fire-and-forget. */
+    warmUp(): void;
+    /**
+     * Join a room. Recording starts automatically on join and stops on
+     * leave(). Rejects if the connection fails.
+     *
+     * `consent` is REQUIRED — produce it with <CrowdPlayConsentScreen> or from
+     * your own UI at the moment of agreement. There is no way to record
+     * without it, here or natively.
+     */
+    join(options: {
+        displayName: string;
+        roomCode: string;
+        consent: ConsentGrant;
+    }): Promise<void>;
+    /** Leave the room. Recording stops; uploads proceed automatically (they
+     * survive backgrounding; force-quit pauses them until next launch). */
+    leave(): Promise<void>;
+    /** Mutes the call AND writes silence into the recording (never records
+     * someone who believes they are muted). */
+    setMicMuted(muted: boolean): Promise<void>;
+    /** Camera off sends + records black frames; the timeline stays continuous. */
+    setCameraEnabled(enabled: boolean): Promise<void>;
+    /** Retry after a `recording` event with an error (the meeting is NOT
+     * being captured until this succeeds). */
+    retryRecording(): void;
+    /** Re-attempts any uploads that settled as failed. */
+    /** Route call audio: 'automatic' = the connected device (AirPods,
+     * wired, ...), 'speaker' = force the loudspeaker. Pair with the
+     * 'audioRoute' event to build an output menu. */
+    setAudioOutput(output: "automatic" | "speaker"): void;
+    retryUploads(): void;
+    /** Live recording stats (REC timer, input level, silence/clipping). Null
+     * when not recording. Poll ~1 Hz for a status line. */
+    snapshot(): Promise<RecordingSnapshot | null>;
+    /** Integration self-check: configuration, permissions, disk, backend
+     * reachability, app-key auth. Every failing check names its fix. */
+    doctor(): Promise<DoctorCheck[]>;
+    /** Subscribe to state events. Returns a subscription; call .remove(). */
+    addListener<E extends CrowdPlayEventName>(event: E, listener: (payload: CrowdPlayEvents[E]) => void): {
+        remove(): void;
+    };
+};
+export default CrowdPlay;
+export { CrowdPlayConsentScreen } from './ConsentScreen';
+export { CrowdPlayVideoView } from './VideoView';