peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-engine/src/render-worker/host-service-protocol.d.ts

@@ -0,0 +1,756 @@
+import type { AudioNativeOperation } from '../engine/audioContract.d.ts';
+import type { MetalDirectOperation, MetalCommandOperation, MetalDirectResponse } from '../engine/metalDirectContract.d.ts';
+import type { MetalShaderCompileRequest, MetalShaderCompileResponse } from '../engine/metalShaderContract.d.ts';
+import type { RiveOperation, RiveSyncOperation, RiveHostResponse } from '../engine/riveContract.d.ts';
+import type { WebRTCRequest, WebRTCResponse, WebRTCEvent } from '../engine/webrtcContract.d.ts';
+import type { BrowserSessionResult, VideoThumbnailOptions, VideoThumbnailResult } from '../react-native/host-services.d.ts';
+import type { WebAuthenticationHostRequest, WebAuthenticationHostResult } from '../webAuthenticationContract.d.ts';
+import type { SootSimAudioRecorderCommand, SootSimAudioRecorderOptions, SootSimAudioRecorderSnapshot, PeachCameraSourceInfo, PeachCameraSourceConfiguration, PeachCameraFrameResult, PeachCameraPhotoOptions, PeachCameraPhotoResult, PeachCameraRecordingCommand, PeachCameraRecordingEvent, PeachCameraRecordingOptions, SootSimClipboardBridge, SootSimClipboardImage, SootSimClipboardChange, SootSimSpeechSynthesisEvent, SootSimSpeechSynthesisUtterance } from '../../../peach-globals/src/index.d.ts';
+export type HostServiceCameraFacing = 'user' | 'environment';
+export type HostServiceSpeechRecognitionOptions = {
+    lang: string;
+    continuous: boolean;
+    interimResults: boolean;
+    maxAlternatives: number;
+};
+export type HostServiceSpeechRecognitionEvent = {
+    type: 'start' | 'end' | 'audiostart' | 'audioend' | 'speechstart' | 'speechend' | 'soundstart' | 'soundend' | 'nomatch';
+} | {
+    type: 'error';
+    error: string;
+    message: string;
+} | {
+    type: 'result';
+    resultIndex: number;
+    results: Array<{
+        isFinal: boolean;
+        alternatives: Array<{
+            transcript: string;
+            confidence: number;
+        }>;
+    }>;
+};
+export type HostServiceGeolocationOptions = {
+    enableHighAccuracy?: boolean;
+    timeout?: number;
+    maximumAge?: number;
+};
+export type HostServiceGeolocationPosition = {
+    mocked: boolean;
+    coords: {
+        latitude: number;
+        longitude: number;
+        altitude: number | null;
+        accuracy: number;
+        altitudeAccuracy: number | null;
+        heading: number | null;
+        speed: number | null;
+    };
+    timestamp: number;
+};
+export type HostServiceGeolocationError = {
+    code: number;
+    message: string;
+};
+export type HostServiceDetectedBarcode = {
+    format: string;
+    rawValue: string;
+    boundingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    cornerPoints: Array<{
+        x: number;
+        y: number;
+    }>;
+};
+export type HostServiceVideoSource = {
+    uri?: string;
+    headers?: Record<string, string>;
+};
+export type HostServiceVideoEvent = import('../../../peach-globals/src/index.d.ts').SootSimVideoEvent;
+export type HostServiceAudioEventType = 'loadstart' | 'loadedmetadata' | 'loadeddata' | 'canplay' | 'canplaythrough' | 'play' | 'playing' | 'pause' | 'seeking' | 'seeked' | 'timeupdate' | 'ended' | 'durationchange' | 'volumechange' | 'ratechange' | 'waiting' | 'error';
+export type HostServiceAudioEvent = {
+    type: HostServiceAudioEventType;
+    currentTime: number;
+    duration: number;
+    paused: boolean;
+    ended: boolean;
+    readyState: number;
+    bufferedEnd: number;
+    muted: boolean;
+    volume: number;
+    playbackRate: number;
+    error?: {
+        code: number;
+        message: string;
+    };
+};
+export type HostServiceMediaMetadata = {
+    title: string;
+    artist: string;
+    album: string;
+    artwork: MediaImage[];
+};
+export type HostServiceRequest = {
+    type: 'pdfDocumentOpen';
+    bytes: ArrayBuffer;
+    port: MessagePort;
+} | {
+    type: 'nativeViewWebOpen';
+    uri: string;
+    port: MessagePort;
+} | {
+    type: 'metalShaderCompile';
+    requestId: number;
+    request: MetalShaderCompileRequest;
+} | {
+    type: 'metalSubmit';
+    commandId: number;
+    operation: MetalCommandOperation;
+} | {
+    type: 'metalSyncRequest';
+    operation: MetalDirectOperation;
+    reply: SharedArrayBuffer;
+} | {
+    type: 'webrtcRequest';
+    requestId: number;
+    request: WebRTCRequest;
+} | {
+    type: 'webrtcSyncRequest';
+    reply: SharedArrayBuffer;
+    request: WebRTCRequest;
+} | {
+    type: 'webrtcView';
+    viewId: number;
+    streamId: string | null;
+} | {
+    type: 'riveSyncRequest';
+    operation: RiveSyncOperation;
+    reply: SharedArrayBuffer;
+} | {
+    type: 'riveRequest';
+    requestId: number;
+    operation: RiveOperation;
+} | {
+    type: 'rasterizeSvg';
+    requestId: number;
+    bytes: ArrayBuffer;
+    targetWidth: number;
+    targetHeight: number;
+} | {
+    type: 'localStorageEntriesSnapshot';
+    requestId: number;
+    scopeUrl: string;
+} | {
+    type: 'clipboardRead';
+    requestId: number;
+} | {
+    type: 'clipboardWrite';
+    requestId: number;
+    text: string;
+} | {
+    type: 'clipboardImageRead';
+    requestId: number;
+} | {
+    type: 'clipboardImageWrite';
+    requestId: number;
+    image: Parameters<SootSimClipboardBridge['writeImage']>[0];
+} | {
+    type: 'geolocationGetCurrentPosition';
+    requestId: number;
+    options: HostServiceGeolocationOptions;
+} | {
+    type: 'geolocationWatchPosition';
+    requestId: number;
+    watchId: number;
+    options: HostServiceGeolocationOptions;
+} | {
+    type: 'geolocationClearWatch';
+    watchId: number;
+} | {
+    type: 'cameraSourceInfo';
+    requestId: number;
+    facing: HostServiceCameraFacing;
+} | {
+    type: 'cameraStart';
+    requestId: number;
+    facing: HostServiceCameraFacing;
+    configuration?: PeachCameraSourceConfiguration;
+} | {
+    type: 'cameraConfigureSource';
+    requestId: number;
+    configuration: PeachCameraSourceConfiguration;
+} | {
+    type: 'cameraFrameCapture';
+    requestId: number;
+    format: 'source' | 'BGRA';
+} | {
+    type: 'cameraCapture';
+    requestId: number;
+    options?: PeachCameraPhotoOptions;
+} | {
+    type: 'cameraStop';
+    requestId: number;
+} | {
+    type: 'cameraRecordingStart';
+    requestId: number;
+    recordingId: number;
+    options: PeachCameraRecordingOptions;
+} | {
+    type: 'cameraRecordingCommand';
+    recordingId?: string;
+    requestId: number;
+    command: PeachCameraRecordingCommand;
+} | {
+    type: 'barcodeScanStart';
+    requestId: number;
+    formats: string[];
+} | {
+    type: 'barcodeScanStop';
+    requestId: number;
+} | {
+    type: 'videoCreate';
+    instanceId: number;
+    source: HostServiceVideoSource | null;
+} | {
+    type: 'videoCommand';
+    instanceId: number;
+    command: 'play' | 'pause' | 'replay' | 'seekBy' | 'replace';
+    value?: number | HostServiceVideoSource | null;
+} | {
+    type: 'videoSetProperty';
+    instanceId: number;
+    property: 'currentTime' | 'loop' | 'muted' | 'playbackRate' | 'preservesPitch' | 'timeUpdateEventInterval' | 'timeUpdatesWhilePaused' | 'volume';
+    value: number | boolean;
+} | {
+    type: 'videoDispose';
+    instanceId: number;
+} | {
+    type: 'audioRecorderRequest';
+    requestId: number;
+    id: string;
+    command: SootSimAudioRecorderCommand;
+    options?: SootSimAudioRecorderOptions;
+} | {
+    type: 'audioRecorderRelease';
+    id: string;
+} | {
+    type: 'audioOutputOpen';
+    port: MessagePort;
+} | {
+    type: 'audioInputOpen';
+    port: MessagePort;
+} | {
+    type: 'audioCreate';
+    instanceId: number;
+    src?: string | null;
+} | {
+    type: 'audioNativeRequest';
+    source?: string;
+    value?: number;
+    instanceId: number;
+    operation: AudioNativeOperation;
+    reply: SharedArrayBuffer;
+} | {
+    type: 'audioCommand';
+    instanceId: number;
+    command: 'play' | 'pause' | 'load';
+} | {
+    type: 'audioSetProperty';
+    instanceId: number;
+    property: 'src' | 'currentTime' | 'volume' | 'muted' | 'loop' | 'playbackRate' | 'preservesPitch' | 'preload' | 'crossOrigin' | 'autoplay';
+    value: string | number | boolean | null;
+} | {
+    type: 'audioDispose';
+    instanceId: number;
+} | {
+    type: 'mediaSessionMetadata';
+    metadata: HostServiceMediaMetadata | null;
+} | {
+    type: 'mediaSessionPlaybackState';
+    state: MediaSessionPlaybackState;
+} | {
+    type: 'mediaSessionActionHandler';
+    action: MediaSessionAction;
+    enabled: boolean;
+} | {
+    type: 'mediaSessionPositionState';
+    state: MediaPositionState | null;
+} | {
+    type: 'speechSynthesisSpeak';
+    utteranceId: number;
+    utterance: SootSimSpeechSynthesisUtterance;
+} | {
+    type: 'speechSynthesisCommand';
+    command: 'pause' | 'resume' | 'cancel';
+} | {
+    type: 'speechRecognitionStart';
+    requestId: number;
+    instanceId: number;
+    options: HostServiceSpeechRecognitionOptions;
+} | {
+    type: 'speechRecognitionStop';
+    requestId: number;
+    instanceId: number;
+} | {
+    type: 'speechRecognitionAbort';
+    requestId: number;
+    instanceId: number;
+} | {
+    type: 'rnImageGetSize';
+    requestId: number;
+    uri: string;
+    headers?: Record<string, string>;
+} | {
+    type: 'rnVideoThumbnail';
+    requestId: number;
+    uri: string;
+    options: VideoThumbnailOptions;
+} | {
+    type: 'rnImagePrefetch';
+    requestId: number;
+    uri: string;
+    imageRequestId?: number;
+    exactCacheKey?: string;
+    headers?: Record<string, string>;
+} | {
+    type: 'rnImageStoreBytes';
+    requestId: number;
+    uri: string;
+    bytes: ArrayBuffer;
+    headers?: Record<string, string>;
+} | {
+    type: 'rnImageAbort';
+    requestId: number;
+    imageRequestId: number;
+} | {
+    type: 'rnImageQueryCache';
+    requestId: number;
+    uris: string[];
+} | {
+    type: 'rnLinkingOpenUrl';
+    requestId: number;
+    url: string;
+} | {
+    type: 'rnBrowserOpen';
+    requestId: number;
+    sessionOwner: string;
+    url: string;
+    windowName?: string;
+    windowFeatures?: string;
+} | {
+    type: 'rnWebAuthentication';
+    requestId: number;
+    request: WebAuthenticationHostRequest;
+} | {
+    type: 'rnBrowserDismiss';
+    requestId: number;
+    sessionOwner: string;
+} | {
+    type: 'rnScreenWakeLockIsAvailable';
+    requestId: number;
+} | {
+    type: 'rnScreenWakeLockActivate';
+    requestId: number;
+    reference: string;
+    restoreOnVisible: boolean;
+} | {
+    type: 'rnScreenWakeLockDeactivate';
+    requestId: number;
+    reference: string;
+};
+export type HostServiceResponse = {
+    type: 'rnWebAuthenticationResult';
+    requestId: number;
+    ok: boolean;
+    result?: WebAuthenticationHostResult;
+    error?: string;
+} | {
+    type: 'metalShaderCompileResult';
+    requestId: number;
+    response: MetalShaderCompileResponse;
+} | {
+    type: 'metalCommandResult';
+    commandId: number;
+    response: MetalDirectResponse;
+} | {
+    type: 'webrtcResult';
+    requestId: number;
+    response: WebRTCResponse;
+} | {
+    type: 'webrtcEvent';
+    event: WebRTCEvent;
+} | {
+    type: 'webrtcFrame';
+    viewId: number;
+    bitmap: ImageBitmap;
+    width: number;
+    height: number;
+} | RiveHostResponse | {
+    type: 'rasterizeSvgResult';
+    requestId: number;
+    pngBytes: ArrayBuffer | null;
+} | {
+    type: 'localStorageEntriesSnapshotResult';
+    requestId: number;
+    entries: Array<[string, string]>;
+} | {
+    type: 'clipboardReadResult';
+    requestId: number;
+    ok: boolean;
+    text?: string;
+    error?: string;
+} | {
+    type: 'clipboardWriteResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'clipboardImageReadResult';
+    requestId: number;
+    ok: boolean;
+    image?: SootSimClipboardImage | null;
+    error?: string;
+    errorName?: string;
+} | {
+    type: 'clipboardImageWriteResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+    errorName?: string;
+} | {
+    type: 'clipboardChanged';
+    change: SootSimClipboardChange;
+} | {
+    type: 'geolocationGetCurrentPositionResult';
+    requestId: number;
+    ok: boolean;
+    position?: HostServiceGeolocationPosition;
+    error?: HostServiceGeolocationError;
+} | {
+    type: 'geolocationWatchPositionResult';
+    requestId: number;
+    watchId: number;
+    ok: boolean;
+    error?: HostServiceGeolocationError;
+} | {
+    type: 'geolocationPosition';
+    watchId: number;
+    position: HostServiceGeolocationPosition;
+} | {
+    type: 'geolocationError';
+    watchId: number;
+    error: HostServiceGeolocationError;
+} | {
+    type: 'cameraSourceInfoResult';
+    requestId: number;
+    ok: boolean;
+    sourceInfo?: PeachCameraSourceInfo;
+    error?: string;
+} | {
+    type: 'cameraStartResult';
+    requestId: number;
+    ok: boolean;
+    width?: number;
+    height?: number;
+    error?: string;
+} | {
+    type: 'cameraCaptureResult';
+    requestId: number;
+    ok: boolean;
+    photo?: PeachCameraPhotoResult | null;
+    error?: string;
+} | {
+    type: 'cameraFrameCaptureResult';
+    requestId: number;
+    ok: boolean;
+    frame?: PeachCameraFrameResult;
+    error?: string;
+} | {
+    type: 'cameraConfigureSourceResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'cameraStopResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'cameraRecordingResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'cameraRecordingEvent';
+    recordingId: number;
+    event: PeachCameraRecordingEvent;
+} | {
+    type: 'cameraFrame';
+    bitmap: ImageBitmap;
+    width: number;
+    height: number;
+} | {
+    type: 'barcodeScanStartResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'barcodeScanStopResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'barcodeScanResult';
+    barcodes: HostServiceDetectedBarcode[];
+    videoWidth: number;
+    videoHeight: number;
+} | {
+    type: 'videoEvent';
+    instanceId: number;
+    event: HostServiceVideoEvent;
+} | {
+    type: 'audioRecorderResult';
+    requestId: number;
+    ok: boolean;
+    snapshot?: SootSimAudioRecorderSnapshot;
+    error?: string;
+} | {
+    type: 'audioRecorderSnapshot';
+    id: string;
+    snapshot: SootSimAudioRecorderSnapshot;
+} | {
+    type: 'audioEvent';
+    instanceId: number;
+    event: HostServiceAudioEvent;
+} | {
+    type: 'mediaSessionAction';
+    details: MediaSessionActionDetails;
+} | {
+    type: 'speechSynthesisEvent';
+    utteranceId: number;
+    event: SootSimSpeechSynthesisEvent;
+} | {
+    type: 'videoFrame';
+    instanceId: number;
+    bitmap: ImageBitmap;
+    width: number;
+    height: number;
+} | {
+    type: 'speechRecognitionStartResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'speechRecognitionStopResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'speechRecognitionAbortResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'speechRecognitionEvent';
+    instanceId: number;
+    event: HostServiceSpeechRecognitionEvent;
+} | {
+    type: 'rnImageGetSizeResult';
+    requestId: number;
+    ok: boolean;
+    size?: {
+        width: number;
+        height: number;
+    };
+    error?: string;
+} | {
+    type: 'rnVideoThumbnailResult';
+    requestId: number;
+    ok: boolean;
+    thumbnail?: VideoThumbnailResult;
+    error?: string;
+} | {
+    type: 'rnImagePrefetchResult';
+    requestId: number;
+    ok: boolean;
+    loaded?: boolean;
+    error?: string;
+} | {
+    type: 'rnImageStoreBytesResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'rnImageAbortResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'rnImageQueryCacheResult';
+    requestId: number;
+    ok: boolean;
+    entries?: Record<string, 'memory'>;
+    error?: string;
+} | {
+    type: 'rnLinkingOpenUrlResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'rnBrowserOpenResult';
+    requestId: number;
+    ok: boolean;
+    result?: BrowserSessionResult;
+    error?: string;
+} | {
+    type: 'rnBrowserDismissResult';
+    requestId: number;
+    ok: boolean;
+    result?: {
+        type: 'dismiss';
+    };
+    error?: string;
+} | {
+    type: 'rnScreenWakeLockIsAvailableResult';
+    requestId: number;
+    available: boolean;
+} | {
+    type: 'rnScreenWakeLockActivateResult';
+    requestId: number;
+    ok: boolean;
+    error?: string;
+} | {
+    type: 'rnScreenWakeLockDeactivateResult';
+    requestId: number;
+    ok: boolean;
+    active: boolean;
+    error?: string;
+} | {
+    type: 'rnScreenWakeLockReleased';
+    references: string[];
+};
+type ReactNativeHostServiceRequest = Extract<HostServiceRequest, {
+    type: 'rnImageGetSize' | 'rnVideoThumbnail' | 'rnImagePrefetch' | 'rnImageStoreBytes' | 'rnImageAbort' | 'rnImageQueryCache' | 'rnLinkingOpenUrl' | 'rnWebAuthentication' | 'rnBrowserOpen' | 'rnBrowserDismiss' | 'rnScreenWakeLockIsAvailable' | 'rnScreenWakeLockActivate' | 'rnScreenWakeLockDeactivate' | 'geolocationGetCurrentPosition' | 'geolocationWatchPosition' | 'geolocationClearWatch';
+}>;
+type ReactNativeHostServiceResponse = Extract<HostServiceResponse, {
+    type: 'rnImageGetSizeResult' | 'rnVideoThumbnailResult' | 'rnImageStoreBytesResult' | 'rnImagePrefetchResult' | 'rnImageAbortResult' | 'rnImageQueryCacheResult' | 'rnLinkingOpenUrlResult' | 'rnWebAuthenticationResult' | 'rnBrowserOpenResult' | 'rnBrowserDismissResult' | 'rnScreenWakeLockIsAvailableResult' | 'rnScreenWakeLockActivateResult' | 'rnScreenWakeLockDeactivateResult' | 'rnScreenWakeLockReleased' | 'geolocationGetCurrentPositionResult' | 'geolocationWatchPositionResult' | 'geolocationPosition' | 'geolocationError';
+}>;
+export type ShellHostServiceRequest = Exclude<HostServiceRequest, ReactNativeHostServiceRequest>;
+export type ShellHostServiceResponse = Exclude<HostServiceResponse, ReactNativeHostServiceResponse>;
+export type HostServiceRasterizeSvgResult = Extract<HostServiceResponse, {
+    type: 'rasterizeSvgResult';
+}>;
+export type HostServiceLocalStorageEntriesSnapshotResult = Extract<HostServiceResponse, {
+    type: 'localStorageEntriesSnapshotResult';
+}>;
+export type HostServiceClipboardReadResult = Extract<HostServiceResponse, {
+    type: 'clipboardReadResult';
+}>;
+export type HostServiceClipboardWriteResult = Extract<HostServiceResponse, {
+    type: 'clipboardWriteResult';
+}>;
+export type HostServiceGeolocationGetCurrentPositionResult = Extract<HostServiceResponse, {
+    type: 'geolocationGetCurrentPositionResult';
+}>;
+export type HostServiceGeolocationWatchPositionResult = Extract<HostServiceResponse, {
+    type: 'geolocationWatchPositionResult';
+}>;
+export type HostServiceGeolocationPositionEvent = Extract<HostServiceResponse, {
+    type: 'geolocationPosition';
+}>;
+export type HostServiceGeolocationErrorEvent = Extract<HostServiceResponse, {
+    type: 'geolocationError';
+}>;
+export type HostServiceCameraStartResult = Extract<HostServiceResponse, {
+    type: 'cameraStartResult';
+}>;
+export type HostServiceCameraSourceInfoResult = Extract<HostServiceResponse, {
+    type: 'cameraSourceInfoResult';
+}>;
+export type HostServiceCameraCaptureResult = Extract<HostServiceResponse, {
+    type: 'cameraCaptureResult';
+}>;
+export type HostServiceCameraStopResult = Extract<HostServiceResponse, {
+    type: 'cameraStopResult';
+}>;
+export type HostServiceCameraFrame = Extract<HostServiceResponse, {
+    type: 'cameraFrame';
+}>;
+export type HostServiceBarcodeScanStartResult = Extract<HostServiceResponse, {
+    type: 'barcodeScanStartResult';
+}>;
+export type HostServiceBarcodeScanStopResult = Extract<HostServiceResponse, {
+    type: 'barcodeScanStopResult';
+}>;
+export type HostServiceBarcodeScanResult = Extract<HostServiceResponse, {
+    type: 'barcodeScanResult';
+}>;
+export type HostServiceVideoHostEvent = Extract<HostServiceResponse, {
+    type: 'videoEvent';
+}>;
+export type HostServiceAudioHostEvent = Extract<HostServiceResponse, {
+    type: 'audioEvent';
+}>;
+export type HostServiceMediaSessionAction = Extract<HostServiceResponse, {
+    type: 'mediaSessionAction';
+}>;
+export type HostServiceSpeechSynthesisHostEvent = Extract<HostServiceResponse, {
+    type: 'speechSynthesisEvent';
+}>;
+export type HostServiceVideoFrame = Extract<HostServiceResponse, {
+    type: 'videoFrame';
+}>;
+export type HostServiceSpeechRecognitionStartResult = Extract<HostServiceResponse, {
+    type: 'speechRecognitionStartResult';
+}>;
+export type HostServiceSpeechRecognitionStopResult = Extract<HostServiceResponse, {
+    type: 'speechRecognitionStopResult';
+}>;
+export type HostServiceSpeechRecognitionAbortResult = Extract<HostServiceResponse, {
+    type: 'speechRecognitionAbortResult';
+}>;
+export type HostServiceSpeechRecognitionHostEvent = Extract<HostServiceResponse, {
+    type: 'speechRecognitionEvent';
+}>;
+export type HostServiceRNImageGetSizeResult = Extract<HostServiceResponse, {
+    type: 'rnImageGetSizeResult';
+}>;
+export type HostServiceRNVideoThumbnailResult = Extract<HostServiceResponse, {
+    type: 'rnVideoThumbnailResult';
+}>;
+export type HostServiceRNImagePrefetchResult = Extract<HostServiceResponse, {
+    type: 'rnImagePrefetchResult';
+}>;
+export type HostServiceRNImageAbortResult = Extract<HostServiceResponse, {
+    type: 'rnImageAbortResult';
+}>;
+export type HostServiceRNImageQueryCacheResult = Extract<HostServiceResponse, {
+    type: 'rnImageQueryCacheResult';
+}>;
+export type HostServiceRNLinkingOpenUrlResult = Extract<HostServiceResponse, {
+    type: 'rnLinkingOpenUrlResult';
+}>;
+export type HostServiceRNBrowserOpenResult = Extract<HostServiceResponse, {
+    type: 'rnBrowserOpenResult';
+}>;
+export type HostServiceRNBrowserDismissResult = Extract<HostServiceResponse, {
+    type: 'rnBrowserDismissResult';
+}>;
+export type HostServiceRNScreenWakeLockIsAvailableResult = Extract<HostServiceResponse, {
+    type: 'rnScreenWakeLockIsAvailableResult';
+}>;
+export type HostServiceRNScreenWakeLockActivateResult = Extract<HostServiceResponse, {
+    type: 'rnScreenWakeLockActivateResult';
+}>;
+export type HostServiceRNScreenWakeLockDeactivateResult = Extract<HostServiceResponse, {
+    type: 'rnScreenWakeLockDeactivateResult';
+}>;
+export type HostServiceRNScreenWakeLockReleased = Extract<HostServiceResponse, {
+    type: 'rnScreenWakeLockReleased';
+}>;
+export declare function isHostServiceRequestType(type: string): type is HostServiceRequest['type'];
+export {};