peachsim 0.1.1644 → 0.1.1653

package/dist-types/packages/peach-kit/src/capabilities.d.ts

@@ -0,0 +1,721 @@
+import type { ShellInteractiveEdgeSwipeSpec, ShellInteractiveFormSheetSpec } from '../../peach-compat/src/stubs/screen-transition-math.d.ts';
+import type { ScreenFormSheetCommit, ScreenFormSheetMotion } from '../../peach-engine/src/render-worker/screen-form-sheet-commit-protocol.d.ts';
+import type { ScreenInfo } from './navigation-types.d.ts';
+import type { ShellNativeEvaluationOwner, SystemPermissionDescriptor, SystemPermissionKind, SystemPermissionLocationAccuracy, SystemPermissionState, SystemPermissionStatus, SootsimSettingsPage } from '../../peach-globals/src/index.d.ts';
+import type { ComponentType, ReactNode, ReactPortal } from 'react';
+export type { SystemNotificationSettings, SystemPermissionDescriptor, SystemPermissionKind, SystemPermissionLocationAccuracy, SystemPermissionState, SystemPermissionStatus, } from '../../peach-globals/src/index.d.ts';
+declare const screenTransitionAnimations: readonly ['slide', 'cross-fade', 'simple-push', 'simple-push-from-left', 'android-default', 'slide-from-left', 'slide-from-right', 'android-ios-from-left', 'android-ios-from-right', 'slide-from-bottom', 'sheet-cover', 'modal-cover', 'android-slide-from-bottom', 'fade', 'modal-fade', 'modal-flip', 'android-fade', 'fade-from-bottom', 'android-fade-from-bottom', 'zoom', 'none'];
+export type ScreenTransitionAnimation = (typeof screenTransitionAnimations)[number];
+export interface ScreenTransitionProgress {
+    surfaceId: string;
+    generation: number;
+    stackId: number;
+    transitionId: number;
+    progress: number;
+}
+export declare function isScreenTransitionAnimation(value: unknown): value is ScreenTransitionAnimation;
+export type ScreenEdgeSwipeCommit = {
+    surfaceId: string;
+    generation: number;
+    stackId: number;
+    interactiveId: number;
+    controllerTag: number;
+} & ({
+    phase: 'progress';
+    progress: number;
+} | {
+    phase: 'begin';
+    committed: boolean;
+    behindDimEnabled: boolean;
+    animation: ScreenTransitionAnimation;
+    durationMs: number;
+    screenWidth: number;
+    screenHeight: number;
+} | {
+    phase: 'release' | 'settle';
+    committed: boolean;
+});
+export interface SymbolImageBox {
+    width: number;
+    height: number;
+}
+export interface TabBarIconImage {
+    source: {
+        uri: string;
+        width?: number;
+        height?: number;
+        scale?: number;
+    } | number;
+    template: boolean;
+}
+export interface BottomTabBarItem {
+    label: string;
+    testID?: string;
+    accessibilityLabel?: string;
+    icon?: string;
+    iconName?: string;
+    selectedIconName?: string;
+    allowCustomSymbols?: boolean;
+    iconRenderingMode?: 'default' | 'monochrome' | 'original';
+    selectedIconRenderingMode?: BottomTabBarItem['iconRenderingMode'];
+    labelPositionAdjustment?: {
+        stacked?: {
+            horizontal?: number;
+            vertical?: number;
+        };
+        inline?: {
+            horizontal?: number;
+            vertical?: number;
+        };
+        compactInline?: {
+            horizontal?: number;
+            vertical?: number;
+        };
+    };
+    symbolVariant?: 'fill';
+    selectedSymbolVariant?: 'fill';
+    materialIconName?: string;
+    selectedMaterialIconName?: string;
+    iconImage?: TabBarIconImage;
+    selectedIconImage?: TabBarIconImage;
+    badge?: number | string | {
+        text: string;
+    };
+    androidBadgeText?: boolean;
+    badgeStyle?: {
+        backgroundColor?: string;
+        color?: string;
+    };
+    labelVisibility?: 'auto' | 'labeled' | 'unlabeled' | 'selected';
+    rippleColor?: string;
+    activeIndicatorColor?: string;
+    activeIndicatorEnabled?: boolean;
+    iconSize?: number;
+    activeIndicatorWidth?: number;
+    activeIndicatorHeight?: number;
+    role?: string;
+    systemItem?: string;
+    prominent?: boolean;
+    activeTintColor?: string;
+    preventsDefault?: boolean;
+}
+export type BottomTabAccessoryPlacement = 'regular' | 'inline';
+export type BottomTabAccessoryRenderer = (placement: BottomTabAccessoryPlacement) => ReactNode;
+export interface MinimizeTracking {
+    readonly value: number;
+    addListener(fn: () => void): () => void;
+}
+export interface BottomTabBarProps {
+    tabs: readonly BottomTabBarItem[];
+    activeIndex: number;
+    hidden?: boolean;
+    visibilityAnimationEnabled?: boolean;
+    onTabPress: (index: number) => boolean | void;
+    onTabLongPress?: (index: number) => void;
+    tabLabelStyle?: {
+        fontFamily?: string;
+        fontWeight?: string;
+        fontSize?: number;
+        fontStyle?: 'normal' | 'italic';
+        color?: string;
+    };
+    selectedTabLabelStyle?: BottomTabBarProps['tabLabelStyle'];
+    colorScheme?: 'light' | 'dark';
+    activeTintColor?: string;
+    inactiveTintColor?: string;
+    activeLabelColor?: string;
+    inactiveLabelColor?: string;
+    tabBarControllerMode?: 'automatic' | 'tabBar' | 'tabSidebar';
+    sidebarVisible?: boolean;
+    onSidebarToggle?: () => void;
+    rippleColor?: string;
+    backgroundColor?: string;
+    hasScrollEdgeEffect?: boolean;
+    materialKey?: string;
+    bottomAccessory?: BottomTabAccessoryRenderer;
+    onBottomInsetChange?: (inset: number) => void;
+    isMinimized?: boolean;
+    minimizeProgress?: number;
+    minimizeTracking?: MinimizeTracking;
+    compressionBehavior?: 'overflow';
+}
+export type GestureSeamOwner = {
+    kind: 'app';
+    peerEpoch: number;
+    surfaceId: 'app:one' | 'app:two';
+    generation: number;
+} | {
+    kind: 'shell-overlay';
+    peerEpoch: number;
+    surfaceId: 'shell-overlay';
+    generation: 1;
+};
+export interface ColorPickerControlProps {
+    color: string;
+    label?: string;
+    children?: ReactNode;
+    disabled?: boolean;
+    supportsOpacity?: boolean;
+    onChange?: (value: string) => void;
+    testID?: string;
+}
+export interface SootSimEngineConfig {
+    components: {
+        View: any;
+        Pressable: any;
+        Text: any;
+        Image: any;
+        ScrollView: any;
+        FlatList: any;
+        SectionList?: any;
+        Modal: any;
+        KeyboardAvoidingView: any;
+        ContextMenu: any;
+        BottomTabBar: ComponentType<BottomTabBarProps>;
+        GlassPress?: any;
+        Slider?: any;
+        SegmentedControl?: any;
+        ColorWheel?: any;
+        ColorPicker: ComponentType<ColorPickerControlProps>;
+        WheelPicker?: any;
+        SfSymbolIcon?: any;
+        Swipeable: any;
+        [key: string]: any;
+    };
+    bottomTabBarHeight?: () => number;
+    topTabBarInset?: () => number;
+    types: {
+        MenuItemConfig: any;
+        MenuGroupConfig: any;
+        TabItem: any;
+        [key: string]: any;
+    };
+    engine: {
+        createPortal: (children: ReactNode, target: unknown, key?: string | null) => ReactPortal;
+        AnimatedValue: any;
+        registerNativeAnimation: (value: any, step: (now: number) => boolean, callback?: (result: {
+            finished: boolean;
+            reason: 'completed' | 'stalled' | 'stopped';
+        }) => void, options?: {
+            priority?: 'normal' | 'low' | 'high';
+            layoutBound?: boolean;
+        }) => number;
+        stopNativeAnimation: (id: number) => void;
+        createTimingStep: (value: any, config: {
+            toValue: number;
+            duration?: number;
+            easing?: (t: number) => number;
+        }) => (now: number) => boolean;
+        createLoopingTimingStep: (value: any, config: {
+            fromValue?: number;
+            toValue: number;
+            duration?: number;
+            easing?: (t: number) => number;
+        }) => (now: number) => boolean;
+        createSpringStep: (value: any, config: any) => (now: number) => boolean;
+        triggerAnimatedRender: (options?: {
+            layout?: boolean;
+            targetNodes?: Set<any>;
+        }) => void;
+        beginScreenTransition: () => () => void;
+        beginNavigationTransition: (kind: 'presenting' | 'dismissing' | 'swiping-back') => () => void;
+        registerScreen: (info: ScreenInfo) => () => void;
+        updateScreen: (id: string, partial: Partial<Omit<ScreenInfo, 'id' | 'owner'>>, owner: ShellNativeEvaluationOwner | null) => boolean;
+        bumpLayoutVersion?: (node?: any) => void;
+        invalidateBoundaryForAnimatedStyle?: (style: {
+            ___sootsimNodeTag?: number;
+        }) => void;
+        beginShellScreenTransition?: (descriptor: any, onStarted: () => void) => boolean;
+        settleShellScreenTransitionEntry?: (owner: Omit<ScreenTransitionProgress, 'progress'>) => void;
+        onShellScreenTransitionProgress: (callback: (event: ScreenTransitionProgress) => void) => () => void;
+        beginShellScreenInteractive?: (descriptor: any) => boolean;
+        updateShellScreenInteractive?: (owner: {
+            interactiveId: number;
+            surfaceId: string;
+            generation: number;
+        }, drag: number) => void;
+        endShellScreenInteractive?: (owner: {
+            interactiveId: number;
+            surfaceId: string;
+            generation: number;
+        }, opts: {
+            commit: boolean;
+            fromDrag: number;
+            velocity: number;
+            stackId: number;
+        }) => void;
+        registerShellInteractiveEdgeSwipe?: (spec: ShellInteractiveEdgeSwipeSpec) => boolean;
+        getShellSurfaceOwner?: (viewTag: number) => {
+            surfaceId: 'app:one' | 'app:two';
+            generation: number;
+        } | null;
+        unregisterShellInteractiveEdgeSwipe?: (owner: {
+            surfaceId: string;
+            generation: number;
+            viewTag: number;
+        }) => void;
+        onShellEdgeSwipeCommit?: (cb: (commit: ScreenEdgeSwipeCommit) => void) => () => void;
+        registerShellInteractiveFormSheet?: (spec: ShellInteractiveFormSheetSpec) => boolean;
+        unregisterShellInteractiveFormSheet?: (owner: {
+            surfaceId: string;
+            generation: number;
+            viewTag: number;
+        }) => void;
+        settleShellInteractiveFormSheet?: (motion: ScreenFormSheetMotion) => void;
+        onShellFormSheetCommit?: (cb: (commit: ScreenFormSheetCommit) => void) => () => void;
+        postGestureSeamRequest?: (req: {
+            kind: 'create';
+            handlerName: string;
+            handlerTag: number;
+            config: Record<string, unknown>;
+            graph: {
+                owner: GestureSeamOwner;
+                detectorId: number;
+                generation: number;
+                revision: number;
+                memberTags: number[];
+                groups: Array<{
+                    kind: 'race' | 'exclusive' | 'simultaneous';
+                    members: number[][];
+                }>;
+                relations: Array<{
+                    handlerTag: number;
+                    simultaneousWith: number[];
+                    requireToFail: number[];
+                    blocksExternal: number[];
+                }>;
+            };
+        } | {
+            kind: 'attach';
+            handlerTag: number;
+            viewTag: number;
+            actionType: number;
+            owner: GestureSeamOwner;
+            viewIsUIControl: boolean;
+            reanimatedEventViewTag?: number;
+            reanimatedHandlerTag?: number;
+        } | {
+            kind: 'update';
+            handlerTag: number;
+            config: Record<string, unknown>;
+            graph: {
+                owner: GestureSeamOwner;
+                detectorId: number;
+                generation: number;
+                revision: number;
+                memberTags: number[];
+                groups: Array<{
+                    kind: 'race' | 'exclusive' | 'simultaneous';
+                    members: number[][];
+                }>;
+                relations: Array<{
+                    handlerTag: number;
+                    simultaneousWith: number[];
+                    requireToFail: number[];
+                    blocksExternal: number[];
+                }>;
+            };
+        } | {
+            kind: 'drop';
+            handlerTag: number;
+            owner: GestureSeamOwner;
+        } | {
+            kind: 'setState';
+            handlerTag: number;
+            newState: number;
+            owner: GestureSeamOwner;
+        }) => void;
+        getGestureSurfaceOwner?: (viewTag: number, nativeNode: unknown) => GestureSeamOwner | null;
+        cancelGesturePointers?: (surfaceId: string, pointerIds: readonly number[], cancelsJSResponder: boolean, cancelsNativeTouch: boolean) => void;
+        registerGestureSeamHandler?: (cb: (event: {
+            owner: GestureSeamOwner;
+            channel: 'stateChange' | 'update';
+            handlerTag: number;
+            state: number;
+            oldState: number;
+            numberOfPointers: number;
+            x?: number;
+            y?: number;
+            absoluteX?: number;
+            absoluteY?: number;
+            translationX?: number;
+            translationY?: number;
+            velocityX?: number;
+            velocityY?: number;
+            velocity?: number;
+            scale?: number;
+            focalX?: number;
+            focalY?: number;
+            rotation?: number;
+            anchorX?: number;
+            anchorY?: number;
+            pointerInside?: boolean;
+            pointerType?: number;
+            stylusData?: Record<string, number>;
+            duration?: number;
+            timestamp?: number;
+            sourcePhase?: 'down' | 'move' | 'up' | 'cancel';
+        } | {
+            owner: GestureSeamOwner;
+            channel: 'touch';
+            handlerTag: number;
+            pointerType: number;
+            x: number;
+            y: number;
+            touches: ReadonlyArray<{
+                pageX: number;
+                pageY: number;
+                identifier: number;
+            }>;
+            viewRect: {
+                pageX: number;
+                pageY: number;
+            };
+            sourcePhase: 'down' | 'move' | 'up' | 'cancel';
+        } | {
+            owner: GestureSeamOwner;
+            channel: 'touchCancellation';
+            handlerTag: number;
+            pointerIds: readonly number[];
+            cancelsJSResponder: boolean;
+            cancelsNativeTouch: boolean;
+            sourcePhase: 'down' | 'move' | 'up' | 'cancel';
+        }) => void) => () => void;
+        beginNativeMenuGesture?: (event?: {
+            pointerId?: number;
+            pageX?: number;
+            pageY?: number;
+        }) => boolean;
+        [key: string]: any;
+    };
+    reactNative: {
+        usePinnedTraitColorScheme: () => 'light' | 'dark' | null;
+        Platform: any;
+        Dimensions: any;
+        UIManager: any;
+        Keyboard: any;
+        findNodeHandle?: (component: any) => number | null;
+        BackHandler: {
+            emitBackPress: () => boolean;
+        };
+        AppRegistry: any;
+        NativeEventEmitter: any;
+        DeviceEventEmitter: any;
+        Animated?: any;
+        Easing?: any;
+        [key: string]: any;
+    };
+    nativeNotifications?: NativeNotificationsConfig;
+    nativeAlerts?: NativeAlertsConfig;
+    nativePermissions?: NativePermissionsConfig;
+    systemPermissions?: NativePermissionsConfig;
+    appSurfaceBackground?: {
+        set: (color: string | number | null) => void;
+        get: () => string | null;
+    };
+    systemBars?: {
+        update: (patch: {
+            behavior?: string | null;
+            statusBar?: {
+                backgroundColor?: string;
+                hidden?: boolean;
+                style?: string;
+                translucent?: boolean;
+            };
+            navigationBar?: {
+                backgroundColor?: string;
+                borderColor?: string | null;
+                hidden?: boolean;
+                position?: string | null;
+                style?: string;
+                translucent?: boolean;
+            };
+        }) => void;
+    };
+    services?: {
+        dynamicColor?: (light: string, dark: string) => any;
+        resolveIOSSemanticColor?: (name: string) => any;
+        liquidGlassPresets?: Record<string, any>;
+        iosStepperCapsule?: any;
+        iosStepperDivider?: any;
+        iosSwitchMetrics?: any;
+        sfSymbolCodePoint?: {
+            get: (name: string) => number | null | undefined;
+            request: (name: string) => Promise<number | null>;
+        };
+        sfSymbolImageBox?: {
+            get: (name: string, size: number, weight?: string) => SymbolImageBox | null;
+            request: (name: string, size: number, weight?: string) => Promise<SymbolImageBox | null>;
+        };
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface NativePermissionsConfig {
+    prepareStatusSnapshot: () => Promise<void>;
+    subscribeStatus: (listener: () => void) => () => void;
+    getStatus: (kind: SystemPermissionKind, owner?: ShellNativeEvaluationOwner) => SystemPermissionStatus;
+    check: (descriptor: SystemPermissionDescriptor, signal?: AbortSignal, owner?: ShellNativeEvaluationOwner) => Promise<SystemPermissionState>;
+    checkMultiple: (descriptors: readonly SystemPermissionDescriptor[]) => Promise<readonly SystemPermissionState[]>;
+    request: (descriptor: SystemPermissionDescriptor, signal?: AbortSignal, owner?: ShellNativeEvaluationOwner) => Promise<SystemPermissionState>;
+    requestMultiple: (descriptors: readonly SystemPermissionDescriptor[]) => Promise<readonly SystemPermissionState[]>;
+    requestLocationAccuracy: (purpose: string) => Promise<SystemPermissionLocationAccuracy>;
+    setLimitedResources: (kind: SystemPermissionKind, resourceIds: readonly string[], owner?: ShellNativeEvaluationOwner) => Promise<void>;
+    openLimitedPhotoLibraryPicker: () => Promise<void>;
+    openSettings: (route: {
+        kind: 'app';
+    } | {
+        kind: 'system';
+        page: SootsimSettingsPage;
+    }, owner?: ShellNativeEvaluationOwner) => Promise<void>;
+}
+export type NativeAlertPromptValue = string | {
+    login: string;
+    password: string;
+};
+export interface NativeAlertsConfig {
+    showSystem: (title: string, message: string, buttons: Array<NonNullable<Parameters<NativeAlertsConfig['show']>[2]>[number] & {
+        settingsRoute?: Parameters<NativePermissionsConfig['openSettings']>[0];
+    }>) => number;
+    show: (title: string, message?: string, buttons?: Array<{
+        text?: string;
+        style?: 'default' | 'cancel' | 'destructive';
+        isPreferred?: boolean;
+        onPress?: (value?: NativeAlertPromptValue) => void;
+    }>, options?: {
+        cancelable?: boolean;
+        onDismiss?: () => void;
+    }, traitScheme?: 'light' | 'dark' | null) => number;
+    dismiss: (handle: number) => void;
+    showActionSheet: (spec: {
+        title?: string;
+        message?: string;
+        options: string[];
+        animated?: boolean;
+        permittedArrowDirections?: number;
+        disabledButtonIndices?: number[];
+        preferredButtonIndex?: number;
+        cancelButtonIndex?: number;
+        destructiveButtonIndex?: number | number[];
+        sourceRect?: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    }, onSelect: (index: number) => void, traitScheme?: 'light' | 'dark' | null, lifecycle?: {
+        onDidPresent?: () => void;
+        onWillDismiss?: () => void;
+        onDidDismiss?: () => void;
+    }) => number;
+    dismissActionSheet: (handle: number) => void;
+    isWindowTintDimmed: () => boolean;
+    subscribeWindowTintDimmed: (listener: () => void) => () => void;
+}
+export interface NativeNotificationsConfig {
+    push: (spec: {
+        appName: string;
+        body: string;
+        iconColor?: string;
+        id: string;
+        time?: string;
+        title: string;
+    }, onTap?: () => void) => void;
+    dismiss: (id: string) => void;
+    bus: NotificationBusInterface;
+}
+export interface NotifChannel {
+    id: string;
+    name?: string;
+    description?: string;
+    importance?: number;
+    groupId?: string;
+    sound?: string | null;
+    vibrationPattern?: number[] | null;
+    enableVibrate?: boolean;
+    enableLights?: boolean;
+    lightColor?: string;
+    visibility?: number;
+    bypassDnd?: boolean;
+    showBadge?: boolean;
+    blocked?: boolean;
+}
+export interface NotifChannelGroup {
+    id: string;
+    name?: string;
+    description?: string;
+    blocked?: boolean;
+}
+export interface NotifSpec {
+    id: string;
+    title?: string;
+    body?: string;
+    subtitle?: string;
+    data?: Record<string, unknown>;
+    pushPayload?: Record<string, unknown>;
+    channelId?: string;
+    categoryId?: string;
+    color?: string;
+    badge?: number;
+    threadId?: string;
+    contentAvailable?: 0 | 1;
+    smallIcon?: string;
+    largeIcon?: string;
+    autoCancel?: boolean;
+    ongoing?: boolean;
+    groupId?: string;
+    subText?: string;
+    raw?: Record<string, unknown>;
+    origin?: 'notifee' | 'expo' | 'rnpn' | 'rnpn-ios' | 'fcm' | 'airship' | 'onesignal';
+}
+export type NotifTrigger = {
+    type: 'timestamp';
+    timestamp: number;
+    repeats?: boolean;
+} | {
+    type: 'interval';
+    seconds: number;
+    repeats?: boolean;
+} | {
+    type: 'date';
+    date: number;
+    repeats?: boolean;
+} | {
+    type: 'daily';
+    hour: number;
+    minute: number;
+    utc?: boolean;
+} | {
+    type: 'weekly';
+    weekday: number;
+    hour: number;
+    minute: number;
+    utc?: boolean;
+} | {
+    type: 'calendar';
+    year?: number;
+    month?: number;
+    day?: number;
+    weekday?: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+    utc?: boolean;
+} | {
+    type: 'location';
+    latitude: number;
+    longitude: number;
+    radius: number;
+    identifier: string;
+    notifyOnEntry: boolean;
+    notifyOnExit: boolean;
+    repeats: boolean;
+} | null;
+export type NotifEventType = 'delivered' | 'pressed' | 'dismissed' | 'received' | 'channel-blocked' | 'app-blocked' | 'trigger-created' | 'badge-changed' | 'permission-changed' | 'token-changed';
+export interface NotifPermission {
+    status: 'undetermined' | 'denied' | 'granted' | 'provisional';
+    canAskAgain: boolean;
+    alert: boolean;
+    badge: boolean;
+    sound: boolean;
+    critical?: boolean;
+    lockScreen?: boolean;
+    notificationCenter?: boolean;
+    showPreviews?: 'always' | 'whenUnlocked' | 'never';
+    announcement?: boolean;
+    carPlay?: boolean;
+    inAppNotificationSettings?: boolean;
+    authorizationStatus: number;
+}
+export interface NotifToken {
+    type: 'expo' | 'apns' | 'fcm' | 'browser' | 'voip';
+    data: string;
+}
+export interface NotifEvent {
+    type: NotifEventType;
+    notification?: NotifSpec;
+    actionId?: string;
+    userText?: string;
+    badge?: number;
+    permission?: NotifPermission;
+    token?: NotifToken;
+}
+export interface NotifAction {
+    id: string;
+    title: string;
+    options?: Record<string, unknown>;
+    destructive?: boolean;
+    foreground?: boolean;
+    textInput?: {
+        buttonTitle?: string;
+        placeholder?: string;
+    };
+}
+export interface NotifCategory {
+    id: string;
+    actions: NotifAction[];
+    options?: Record<string, unknown>;
+}
+export interface NotifPresentation {
+    banner: boolean;
+    list: boolean;
+    sound: boolean;
+    badge: boolean;
+    alert?: boolean;
+}
+export type NotifForegroundPresenter = (spec: NotifSpec) => Promise<NotifPresentation>;
+export interface NotificationBusInterface {
+    createChannel: (channel: NotifChannel) => NotifChannel;
+    getChannel: (id: string) => NotifChannel | null;
+    deleteChannel: (id: string) => void;
+    getChannels: () => NotifChannel[];
+    isChannelCreated: (id: string) => boolean;
+    isChannelBlocked: (id: string) => boolean;
+    createChannelGroup: (group: NotifChannelGroup) => NotifChannelGroup;
+    getChannelGroup: (id: string) => NotifChannelGroup | null;
+    deleteChannelGroup: (id: string) => void;
+    getChannelGroups: () => NotifChannelGroup[];
+    push: (spec: NotifSpec) => string;
+    dispatchUserNotification: (payload: Record<string, unknown>, opts: {
+        launch: boolean;
+        actionId?: string;
+        userText?: string;
+    }) => string | null;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+    removeDisplayed: (id: string) => void;
+    removeAllDisplayed: () => void;
+    getDisplayed: () => NotifSpec[];
+    setForegroundPresenter: (presenter: NotifForegroundPresenter | null) => void;
+    schedule: (spec: NotifSpec, trigger: NotifTrigger) => string;
+    cancelScheduled: (id: string) => void;
+    cancelAllScheduled: () => void;
+    getScheduled: () => Array<{
+        spec: NotifSpec;
+        trigger: NotifTrigger;
+    }>;
+    getBadge: () => number;
+    setBadge: (count: number) => void;
+    incrementBadge: (by?: number) => void;
+    decrementBadge: (by?: number) => void;
+    requestPermission: (opts?: {
+        alert?: boolean;
+        badge?: boolean;
+        sound?: boolean;
+        critical?: boolean;
+    }) => Promise<NotifPermission>;
+    getPermission: () => Promise<NotifPermission>;
+    getExpoPushToken: () => string;
+    getDevicePushToken: (platform: 'apns' | 'fcm' | 'browser' | 'voip') => NotifToken;
+    setCategory: (category: NotifCategory) => void;
+    getCategories: () => NotifCategory[];
+    deleteCategory: (id: string) => void;
+    getInitialNotification: () => NotifSpec | null;
+    on: (type: NotifEventType, cb: (event: NotifEvent) => void) => () => void;
+    onAny: (cb: (event: NotifEvent) => void) => () => void;
+}
+export declare function setEngineConfig(config: SootSimEngineConfig): void;
+export declare function setEngineConfigInitializer(init: () => SootSimEngineConfig): void;
+export declare function resetCapabilityStore(): void;
+export declare function getOptionalEngineConfig(): SootSimEngineConfig | undefined;
+export declare function getEngineConfig(): SootSimEngineConfig;