spotifyplus 0.1.1

package/internal/legacy-animated.d.ts

@@ -0,0 +1,217 @@
+import React from "react";
+export type EndCallback = (result: {
+    finished: boolean;
+}) => void;
+export type EasingFunction = (value: number) => number;
+export type ExtrapolateType = "extend" | "clamp" | "identity";
+export type AnimatedNodeLike = AnimatedNode;
+export type ListenerCallback = (state: {
+    value: number;
+}) => void;
+export type AnimationConfig = {
+    useNativeDriver?: boolean;
+    isInteraction?: boolean;
+    delay?: number;
+};
+export type TimingAnimationConfig = AnimationConfig & {
+    toValue: number | Value;
+    duration?: number;
+    easing?: EasingFunction;
+};
+export type SpringAnimationConfig = AnimationConfig & {
+    toValue: number | Value;
+    velocity?: number;
+    tension?: number;
+    friction?: number;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    overshootClamping?: boolean;
+    restSpeedThreshold?: number;
+    restDisplacementThreshold?: number;
+    duration?: number;
+};
+export type DecayAnimationConfig = AnimationConfig & {
+    velocity: number;
+    deceleration?: number;
+};
+export type InterpolationConfig = {
+    inputRange: number[];
+    outputRange: Array<number | string>;
+    easing?: EasingFunction;
+    extrapolate?: ExtrapolateType;
+    extrapolateLeft?: ExtrapolateType;
+    extrapolateRight?: ExtrapolateType;
+};
+export type CompositeAnimation = {
+    start(callback?: EndCallback): void;
+    stop(): void;
+    reset(): void;
+};
+type Binding = {
+    id: number;
+    nodeId: number;
+    prop: string;
+    node: AnimatedNode;
+};
+type RunningAnimation = {
+    stop(): void;
+    reset?(): void;
+};
+export declare abstract class AnimatedNode {
+    readonly __isSpotifyPlusAnimatedNode = true;
+    protected bindings: Set<Binding>;
+    protected children: Set<AnimatedNode>;
+    protected listeners: Map<string, ListenerCallback>;
+    abstract __getValue(): any;
+    __attachChild(child: AnimatedNode): void;
+    __detachChild(child: AnimatedNode): void;
+    __addBinding(binding: Binding): void;
+    __removeBinding(binding: Binding): void;
+    __getValueAtRoot(root: Value, rootValue: number): any;
+    __collectBindings(out: Binding[]): void;
+    __notify(): void;
+    addListener(callback: ListenerCallback): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    interpolate(config: InterpolationConfig): AnimatedInterpolation;
+}
+export declare class Value extends AnimatedNode {
+    private value;
+    private offset;
+    private animation;
+    constructor(value: number);
+    __getValue(): number;
+    __getOffset(): number;
+    __setValue(value: number, notify?: boolean): void;
+    __getValueAtRoot(root: Value, rootValue: number): any;
+    __stopCurrentAnimation(): void;
+    __setRunningAnimation(animation: RunningAnimation | null): void;
+    setValue(value: number): void;
+    setOffset(offset: number): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    stopAnimation(callback?: (value: number) => void): void;
+    resetAnimation(callback?: (value: number) => void): void;
+}
+declare class AnimatedInterpolation extends AnimatedNode {
+    private parent;
+    private config;
+    constructor(parent: AnimatedNode, config: InterpolationConfig);
+    __getValue(): string | number;
+    __getValueAtRoot(root: Value, rootValue: number): any;
+}
+declare class AnimatedBinaryOp extends AnimatedNode {
+    private left;
+    private right;
+    private op;
+    constructor(left: number | AnimatedNode, right: number | AnimatedNode, op: (a: number, b: number) => number);
+    __getValue(): number;
+    __getValueAtRoot(root: Value, rootValue: number): any;
+}
+export declare class ValueXY {
+    x: Value;
+    y: Value;
+    constructor(value?: {
+        x?: number;
+        y?: number;
+    });
+    setValue(value: {
+        x: number;
+        y: number;
+    }): void;
+    setOffset(value: {
+        x: number;
+        y: number;
+    }): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    stopAnimation(callback?: (value: {
+        x: number;
+        y: number;
+    }) => void): void;
+    getLayout(): {
+        left: Value;
+        top: Value;
+    };
+    getTranslateTransform(): ({
+        translateX: Value;
+        translateY?: undefined;
+    } | {
+        translateY: Value;
+        translateX?: undefined;
+    })[];
+}
+export declare const Easing: {
+    linear: (t: number) => number;
+    ease: (t: number) => number;
+    quad: (t: number) => number;
+    cubic: (t: number) => number;
+    sin: (t: number) => number;
+    circle: (t: number) => number;
+    exp: (t: number) => number;
+    back: (s?: number) => (t: number) => number;
+    bounce: (t: number) => number;
+    in: (easing: EasingFunction) => (t: number) => number;
+    out: (easing: EasingFunction) => (t: number) => number;
+    inOut: (easing: EasingFunction) => (t: number) => number;
+};
+export declare function timing(value: Value, config: TimingAnimationConfig): CompositeAnimation;
+export declare function spring(value: Value, config: SpringAnimationConfig): CompositeAnimation;
+export declare function decay(value: Value, config: DecayAnimationConfig): CompositeAnimation;
+export declare function delay(time: number): CompositeAnimation;
+export declare function sequence(animations: CompositeAnimation[]): CompositeAnimation;
+export declare function parallel(animations: CompositeAnimation[], config?: {
+    stopTogether?: boolean;
+}): CompositeAnimation;
+export declare function stagger(time: number, animations: CompositeAnimation[]): CompositeAnimation;
+export declare function loop(animation: CompositeAnimation, config?: {
+    iterations?: number;
+}): CompositeAnimation;
+export declare function add(a: number | AnimatedNode, b: number | AnimatedNode): AnimatedBinaryOp;
+export declare function subtract(a: number | AnimatedNode, b: number | AnimatedNode): AnimatedBinaryOp;
+export declare function multiply(a: number | AnimatedNode, b: number | AnimatedNode): AnimatedBinaryOp;
+export declare function divide(a: number | AnimatedNode, b: number | AnimatedNode): AnimatedBinaryOp;
+export declare function modulo(a: number | AnimatedNode, b: number | AnimatedNode): AnimatedBinaryOp;
+export declare function event(mapping: any[], config?: {
+    listener?: (...args: any[]) => void;
+}): (...args: any[]) => void;
+export declare function createAnimatedComponent<P extends {
+    style?: any;
+}>(Component: React.ComponentType<P>): React.ComponentType<P>;
+export declare function useAnimatedValue(initialValue: number): Value;
+declare const Animated: {
+    Value: typeof Value;
+    ValueXY: typeof ValueXY;
+    timing: typeof timing;
+    spring: typeof spring;
+    decay: typeof decay;
+    delay: typeof delay;
+    sequence: typeof sequence;
+    parallel: typeof parallel;
+    stagger: typeof stagger;
+    loop: typeof loop;
+    add: typeof add;
+    subtract: typeof subtract;
+    multiply: typeof multiply;
+    divide: typeof divide;
+    modulo: typeof modulo;
+    event: typeof event;
+    createAnimatedComponent: typeof createAnimatedComponent;
+    useAnimatedValue: typeof useAnimatedValue;
+    Easing: {
+        linear: (t: number) => number;
+        ease: (t: number) => number;
+        quad: (t: number) => number;
+        cubic: (t: number) => number;
+        sin: (t: number) => number;
+        circle: (t: number) => number;
+        exp: (t: number) => number;
+        back: (s?: number) => (t: number) => number;
+        bounce: (t: number) => number;
+        in: (easing: EasingFunction) => (t: number) => number;
+        out: (easing: EasingFunction) => (t: number) => number;
+        inOut: (easing: EasingFunction) => (t: number) => number;
+    };
+};
+export default Animated;

package/internal/native-animation-core.d.ts

@@ -0,0 +1,129 @@
+import React from "react";
+import { type NativeComponentRef } from "spotifyplus/internal/renderer";
+declare const EXPRESSION: unique symbol;
+declare const ANIMATED_STYLE: unique symbol;
+declare const ANIMATED_PROPS: unique symbol;
+export type Extrapolate = "extend" | "clamp" | "identity";
+export type AnimatedPrimitive = number | string | boolean | null;
+export type AnimatedJSON = AnimatedPrimitive | AnimatedJSON[] | {
+    [key: string]: AnimatedJSON;
+};
+export type AnimatedExpr = AnimatedJSON | {
+    $a: "value";
+    id: number;
+    initial: AnimatedJSON;
+} | {
+    $a: "derived";
+    id: number;
+    expr: AnimatedExpr;
+} | {
+    $a: "const";
+    value: AnimatedJSON;
+} | {
+    $a: "playbackClock";
+    unit?: "ms" | "seconds";
+    offset?: number;
+} | {
+    $a: "add" | "sub" | "mul" | "div" | "mod";
+    values: AnimatedExpr[];
+} | {
+    $a: "clamp";
+    input: AnimatedExpr;
+    min: number;
+    max: number;
+} | {
+    $a: "interpolate" | "interpolateColor";
+    input: AnimatedExpr;
+    inputRange: number[];
+    outputRange: Array<number | string>;
+    extrapolateLeft?: Extrapolate;
+    extrapolateRight?: Extrapolate;
+};
+export type TimingConfig = {
+    duration?: number;
+    delay?: number;
+    easing?: "linear" | "ease" | "easeIn" | "easeOut" | "easeInOut";
+};
+export type SpringConfig = {
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    velocity?: number;
+    overshootClamping?: boolean;
+    restSpeedThreshold?: number;
+    restDisplacementThreshold?: number;
+    delay?: number;
+};
+export type InterpolateOptions = {
+    extrapolate?: Extrapolate;
+    extrapolateLeft?: Extrapolate;
+    extrapolateRight?: Extrapolate;
+};
+export type AnimatedStylePayload<T extends Record<string, any> = Record<string, any>> = {
+    readonly [ANIMATED_STYLE]: true;
+    readonly id: number;
+    readonly value: T;
+};
+export type AnimatedPropsPayload<T extends Record<string, any> = Record<string, any>> = {
+    readonly [ANIMATED_PROPS]: true;
+    readonly id: number;
+    readonly value: T;
+};
+export type NativeAnimatedNodeLike<T = any> = AnimatedExpression<T> | SharedValue<T> | DerivedValue<T>;
+export type AnimatedResolvedValue<T> = T extends AnimatedExpression<infer U> ? AnimatedResolvedValue<U> : T;
+export type AnimationDescriptor<T = any> = {
+    readonly __spotifyPlusAnimation: true;
+    readonly node: Record<string, any>;
+    readonly toValue?: T;
+};
+export declare class AnimatedExpression<T = any> {
+    readonly node: AnimatedExpr;
+    readonly [EXPRESSION] = true;
+    constructor(node: AnimatedExpr);
+}
+export declare class SharedValue<T = any> extends AnimatedExpression<T> {
+    readonly id: number;
+    private current;
+    constructor(id: number, initial: T);
+    get value(): T;
+    set value(next: T | AnimationDescriptor<T> | AnimatedExpression<T>);
+    get(): T;
+    set(next: T | AnimationDescriptor<T> | AnimatedExpression<T>): void;
+}
+export declare class DerivedValue<T = any> extends AnimatedExpression<T> {
+    readonly id: number;
+    constructor(id: number, expr: AnimatedExpr);
+    get value(): T;
+}
+export declare function isAnimatedNodeLike(value: unknown): value is NativeAnimatedNodeLike;
+export declare function serializeAnimatedNode(value: unknown): any;
+export declare function useSharedValue<T = number>(initial: T): SharedValue<T>;
+export declare function useDerivedValue<T = any>(factory: () => T, deps?: React.DependencyList): DerivedValue<AnimatedResolvedValue<T>>;
+export declare function useAnimatedStyle<T extends Record<string, any>>(factory: () => T, deps?: React.DependencyList): AnimatedStylePayload<T>;
+export declare function useAnimatedProps<T extends Record<string, any>>(factory: () => T, deps?: React.DependencyList): AnimatedPropsPayload<T>;
+export declare function playbackClock(options?: {
+    unit?: "ms" | "seconds";
+    offset?: number;
+}): AnimatedExpression<number>;
+export declare function interpolate(value: unknown, inputRange: number[], outputRange: number[], options?: InterpolateOptions): AnimatedExpression<number>;
+export declare function interpolateColor(value: unknown, inputRange: number[], outputRange: Array<string | number>, options?: InterpolateOptions): AnimatedExpression<string | number>;
+export declare const add: (...values: unknown[]) => AnimatedExpression<number>;
+export declare const subtract: (...values: unknown[]) => AnimatedExpression<number>;
+export declare const multiply: (...values: unknown[]) => AnimatedExpression<number>;
+export declare const divide: (...values: unknown[]) => AnimatedExpression<number>;
+export declare const modulo: (...values: unknown[]) => AnimatedExpression<number>;
+export declare const clamp: (input: unknown, min: number, max: number) => AnimatedExpression<number>;
+export declare function withTiming<T = number>(toValue: T | AnimatedExpression<T>, config?: TimingConfig): AnimationDescriptor<T>;
+export declare function withSpring<T = number>(toValue: T | AnimatedExpression<T>, config?: SpringConfig): AnimationDescriptor<T>;
+export declare function withDelay<T = any>(delayMs: number, child: AnimationDescriptor<T>): AnimationDescriptor<T>;
+export declare function withSequence<T = any>(...animations: AnimationDescriptor<T>[]): AnimationDescriptor<T>;
+export declare function cancelAnimation(sharedValue: SharedValue<any>): void;
+export declare function runOnUI<T extends (...args: any[]) => any>(fn: T): T;
+export type AnimatedComponentProps<P> = P & {
+    animatedProps?: AnimatedPropsPayload | Record<string, any>;
+    ref?: React.Ref<NativeComponentRef>;
+};
+export declare function createAnimatedComponent<P extends {
+    style?: any;
+}>(Component: React.ComponentType<P>): React.ComponentType<AnimatedComponentProps<P>>;
+export {};

package/internal/native-animation.d.ts

@@ -0,0 +1,8 @@
+import { Animated } from "spotifyplus/internal/components";
+export * from "spotifyplus/react/Animated/core";
+export declare const View: import("react").ComponentType<import("spotifyplus/react/Animated/core").AnimatedComponentProps<import("spotifyplus/internal/components").RefableProps<import("spotifyplus/internal/components").ViewProps, import("spotifyplus/internal/components").View>>>, Text: import("react").ComponentType<import("spotifyplus/react/Animated/core").AnimatedComponentProps<import("spotifyplus/internal/components").RefableProps<import("spotifyplus/internal/components").TextProps, import("spotifyplus/internal/components").Text>>>, Image: import("react").ComponentType<import("spotifyplus/react/Animated/core").AnimatedComponentProps<import("spotifyplus/internal/components").RefableProps<import("spotifyplus/internal/components").ImageProps, import("spotifyplus/internal/components").Image>>>, ScriptView: import("react").ComponentType<import("spotifyplus/react/Animated/core").AnimatedComponentProps<import("spotifyplus/internal/components").RefableProps<import("spotifyplus/internal/components").ScriptViewProps, import("spotifyplus/internal/components").ScriptView>>>, RenderView: import("react").ComponentType<import("spotifyplus/react/Animated/core").AnimatedComponentProps<import("spotifyplus/internal/components").RefableProps<import("spotifyplus/internal/components").ScriptViewProps, import("spotifyplus/internal/components").RenderView>>>, CanvasView: import("react").ComponentType<import("spotifyplus/react/Animated/core").AnimatedComponentProps<import("spotifyplus/internal/components").RefableProps<import("spotifyplus/internal/components").ScriptViewProps, import("spotifyplus/internal/components").CanvasView>>>, ScrollView: import("react").ComponentType<import("spotifyplus/react/Animated/core").AnimatedComponentProps<{
+    style?: any;
+}>>, FlatList: import("react").ComponentType<import("spotifyplus/react/Animated/core").AnimatedComponentProps<{
+    style?: any;
+}>>, createAnimatedComponent: typeof import("spotifyplus/react/Animated/core").createAnimatedComponent, useSharedValue: typeof import("spotifyplus/react/Animated/core").useSharedValue, useDerivedValue: typeof import("spotifyplus/react/Animated/core").useDerivedValue, useAnimatedStyle: typeof import("spotifyplus/react/Animated/core").useAnimatedStyle, useAnimatedProps: typeof import("spotifyplus/react/Animated/core").useAnimatedProps, interpolate: typeof import("spotifyplus/react/Animated/core").interpolate, interpolateColor: typeof import("spotifyplus/react/Animated/core").interpolateColor, withTiming: typeof import("spotifyplus/react/Animated/core").withTiming, withSpring: typeof import("spotifyplus/react/Animated/core").withSpring, withDelay: typeof import("spotifyplus/react/Animated/core").withDelay, withSequence: typeof import("spotifyplus/react/Animated/core").withSequence, cancelAnimation: typeof import("spotifyplus/react/Animated/core").cancelAnimation, runOnUI: typeof import("spotifyplus/react/Animated/core").runOnUI, playbackClock: typeof import("spotifyplus/react/Animated/core").playbackClock;
+export default Animated;

package/internal/renderer.d.ts

@@ -0,0 +1,163 @@
+import React from 'react';
+export type MeasureCallback = (x: number, y: number, width: number, height: number, pageX: number, pageY: number) => void;
+export type MeasureInWindowCallback = (x: number, y: number, width: number, height: number) => void;
+export type ScrollToOptions = {
+    x?: number;
+    y?: number;
+    animated?: boolean;
+};
+export type ScrollToEndOptions = {
+    animated?: boolean;
+};
+export type ScrollToIndexOptions = {
+    index: number;
+    animated?: boolean;
+    viewOffset?: number;
+    viewPosition?: number;
+};
+export type ScrollToOffsetOptions = {
+    offset: number;
+    animated?: boolean;
+};
+export interface NativeComponentRef {
+    readonly nodeId: number;
+    readonly type: string;
+    readonly mounted: boolean;
+    getNativeNodeId(): number;
+    setNativeProps(props: Record<string, any>): void;
+    focus(): void;
+    blur(): void;
+    measure(callback: MeasureCallback): void;
+    measureInWindow(callback: MeasureInWindowCallback): void;
+    scrollTo(options?: ScrollToOptions | number, y?: number, animated?: boolean): void;
+    scrollToEnd(options?: ScrollToEndOptions): void;
+    flashScrollIndicators(): void;
+    dispatchCommand(command: string, args?: Record<string, any>, callback?: (payload: any) => void): void;
+    command(command: string, args?: Record<string, any>, callback?: (payload: any) => void): void;
+}
+export declare function dispatchReactEvent(eventId: number, payload?: any): void;
+export type MutationOp = {
+    op: 'createNode';
+    id: number;
+    type: string;
+    props: Record<string, any>;
+} | {
+    op: 'createText';
+    id: number;
+    text: string;
+} | {
+    op: 'appendChild';
+    parentId: number;
+    childId: number;
+} | {
+    op: 'appendToRoot';
+    childId: number;
+} | {
+    op: 'insertBefore';
+    parentId: number;
+    childId: number;
+    beforeChildId: number;
+} | {
+    op: 'insertInRootBefore';
+    childId: number;
+    beforeChildId: number;
+} | {
+    op: 'removeChild';
+    parentId: number;
+    childId: number;
+} | {
+    op: 'removeFromRoot';
+    childId: number;
+} | {
+    op: 'updateProps';
+    id: number;
+    props: Record<string, any>;
+} | {
+    op: 'updateText';
+    id: number;
+    text: string;
+} | {
+    op: 'setAnimatedProps';
+    nodeId: number;
+    props: Record<string, any>;
+} | {
+    op: 'removeAnimatedProps';
+    nodeId: number;
+} | {
+    op: 'updateAnimatedValue';
+    valueId: number;
+    value: any;
+    animation?: Record<string, any>;
+} | {
+    op: 'cancelAnimatedValue';
+    valueId: number;
+} | {
+    op: 'updateSharedValue';
+    valueId: number;
+    value: any;
+    animation?: Record<string, any>;
+} | {
+    op: 'startNativeAnimation';
+    nodeId: number;
+    animationId: number;
+    type?: string;
+    duration?: number;
+    delay?: number;
+    easing?: string;
+    tracks: Array<{
+        property: string;
+        from: number;
+        to: number;
+    }>;
+} | {
+    op: 'stopNativeAnimation';
+    animationId: number;
+} | {
+    op: 'scriptViewCommand';
+    nodeId: number;
+    command: string;
+    args?: Record<string, any>;
+} | {
+    op: 'destroyNode';
+    id: number;
+} | {
+    op: 'viewCommand';
+    nodeId: number;
+    command: string;
+    args?: Record<string, any>;
+    eventId?: number;
+};
+type CommitDispatcher = (surfaceId: string, ops: MutationOp[]) => void;
+export declare function setCommitDispatcher(dispatcher: CommitDispatcher | null): void;
+type CommitListener = (ops: MutationOp[], tree: any | null) => void;
+export declare function setCommitListener(surfaceId: string, listener: CommitListener): void;
+export declare function clearCommitListener(surfaceId: string): void;
+export declare function dispatchSurfaceOps(surfaceId: string, ops: MutationOp[]): void;
+export declare function dispatchViewCommand(nodeId: number, command: string, args?: Record<string, any>, callback?: (payload: any) => void): void;
+export declare function updateNodeProps(nodeId: number, props: Record<string, any>): void;
+export declare function setAnimatedProps(nodeId: number, props: Record<string, any>): void;
+export declare function removeAnimatedProps(nodeId: number): void;
+export declare function updateAnimatedValue(valueId: number, value: any, animation?: Record<string, any>): void;
+export declare function cancelAnimatedValue(valueId: number): void;
+export declare function updateSharedValue(valueId: number, value: any, animation?: Record<string, any>): void;
+export declare function startNativeAnimation(nodeId: number, config: {
+    animationId: number;
+    type?: string;
+    duration?: number;
+    delay?: number;
+    easing?: string;
+    tracks: Array<{
+        property: string;
+        from: number;
+        to: number;
+    }>;
+}): void;
+export declare function stopNativeAnimation(animationId: number): void;
+export declare function dispatchScriptViewCommand(nodeId: number, command: string, args?: Record<string, any>): void;
+export interface RenderRoot {
+    render(element: React.ReactNode): void;
+    unmount(): void;
+    getTree(): any;
+}
+export declare function createRoot(surfaceId: string): RenderRoot;
+export {};

package/internal/script-api.d.ts

@@ -0,0 +1,72 @@
+import type { ContextMenu, OnClickCallback, PlatformData, Session, ShouldAddCallback, SideDrawerItem, SideOnClickCallback, SpotifyTrack } from "spotifyplus/entities";
+import type { EventHandler, SurfaceRenderer } from "spotifyplus/internal/script-registry";
+
+export interface ScriptConsole {
+    log: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+
+export interface ContextMenuConstructor {
+    new(name: string, onClick: OnClickCallback, shouldAdd?: ShouldAddCallback, disabled?: boolean): ContextMenu;
+}
+
+export interface SideDrawerConstructor {
+    new(name: string, onClick: SideOnClickCallback): SideDrawerItem;
+}
+
+export interface ScriptGlobals {
+    SpotifyPlus: SpotifyPlusApi;
+    console: ScriptConsole;
+    setTimeout: typeof setTimeout;
+    setInterval: typeof setInterval;
+    clearTimeout: typeof clearTimeout;
+    clearInterval: typeof clearInterval;
+    global: unknown;
+    globalThis: unknown;
+}
+
+export interface SpotifyPlusApi {
+    readonly scriptId: string;
+    readonly version: number;
+    log(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    on(eventName: string, handler: EventHandler): void;
+    off(eventName: string, handler: EventHandler): void;
+    request<TPayload = unknown>(name: string, payload?: unknown): Promise<TPayload>;
+    toast(text: string, length?: 'short' | 'long'): void;
+    openUri(uri: string): void;
+    emit(eventName: string, payload?: unknown): void;
+    Platform: {
+        PlatformData: PlatformData;
+        Session: Session;
+        Storage: {
+            set(key: string, value: any): void;
+            get<T = any>(key: string): Promise<T | null>;
+            remove(key: string): void;
+            write(path: string, value: string): void;
+            write<T = any>(path: string, value: T): void;
+            write(path: string, data: Uint8Array | ArrayBuffer): void;
+            read<T = any>(path: string): Promise<T | string | Uint8Array | null>;
+        };
+    };
+    Internal: {
+        getTrack(uri: string): Promise<SpotifyTrack | null>;
+    };
+    Player: {
+        getCurrentTrack(): SpotifyTrack;
+        getProgress(): number;
+        seek(position: number): void;
+        play(): void;
+        pause(): void;
+        togglePlay(): void;
+        skipNext(): void;
+        skipPrevious(): void;
+    };
+    Surfaces: {
+        register(surfaceType: string, renderer: SurfaceRenderer<any>): void;
+    };
+    ContextMenu: ContextMenuConstructor;
+    SideDrawer: SideDrawerConstructor;
+}

package/internal/script-registry.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import type { Surface } from "spotifyplus/entities";
+
+export type EventHandler = (payload: unknown) => void | Promise<void>;
+export type SurfaceRenderer<T extends string = string> = (surface: Surface & { type: T }) => React.ReactElement;