react-native-queue-player 1.0.0

package/lib/typescript/cast/index.d.ts

@@ -0,0 +1,65 @@
+import type { CastConnectOptions, CastDeviceKind, CastDiscoveryState, CastLocalNetworkPermission, CastLocalNetworkPermissionEvent, CastProtocol, CastReceiver, CastReceiverCapabilities, CastRoute, CastSessionDiedEvent, CastSessionEndReason, CastStreamingModel } from '../types';
+export type { CastConnectOptions, CastDeviceKind, CastDiscoveryState, CastLocalNetworkPermission, CastLocalNetworkPermissionEvent, CastProtocol, CastReceiver, CastReceiverCapabilities, CastRoute, CastSessionDiedEvent, CastSessionEndReason, CastStreamingModel, };
+/**
+ * Subscription handle returned by every `add*Listener` function. Call
+ * [remove] to unsubscribe — idempotent + safe inside the listener body.
+ */
+export interface CastSubscription {
+    remove(): void;
+}
+/**
+ * Native error codes surfaced on rejected `connect()` promises. Use these
+ * to detect specific failure modes — e.g. `AUTH_REQUIRED` indicates the
+ * receiver wants a password and the JS layer should prompt the user then
+ * retry with `connect(id, { password })`.
+ */
+export declare const CastErrorCodes: {
+    readonly CONNECT_FAILED: "cast_connect_failed";
+    readonly AUTH_REQUIRED: "cast_auth_required";
+};
+export type CastErrorCode = (typeof CastErrorCodes)[keyof typeof CastErrorCodes];
+/** Protocols the current build actually supports (AirPlay, Chromecast, both). */
+export declare function getSupportedProtocols(): CastProtocol[];
+/** Convenience: true when at least one cast protocol is available. */
+export declare function isCastAvailable(): boolean;
+export interface CastConfig {
+    /** Name advertised to receivers — shown on approval dialogs / now-playing. */
+    deviceName: string;
+    /**
+     * Hide AirPlay receivers running on Mac computers from the device list.
+     * macOS AirPlay Receiver only accepts Apple senders on the same Apple ID,
+     * so it can't be cast to from here — hidden by default. Set `false` to
+     * surface them anyway. Android-only (iOS AirPlay is OS-managed).
+     */
+    hideAirPlayComputers?: boolean;
+}
+export declare function configure(config: CastConfig): Promise<void>;
+export declare function startDiscovery(): Promise<void>;
+export declare function stopDiscovery(): Promise<void>;
+export declare function isDiscovering(): boolean;
+export declare function getReceivers(): CastReceiver[];
+export declare function getCurrentRoute(): CastRoute;
+export declare function connect(receiverId: string, options?: {
+    password?: string;
+}): Promise<void>;
+export declare function disconnect(): Promise<void>;
+/**
+ * Show the system route picker (iOS AVRoutePickerView). On Android there
+ * is no native system Cast picker — render the bundled `RoutePicker`
+ * component instead.
+ */
+export declare function showSystemPicker(): Promise<void>;
+/** Read the active receiver's volume (`0.0..1.0`), or `NaN` when unknown. */
+export declare function getRouteVolume(): number;
+export declare function setRouteVolume(value: number): Promise<void>;
+export declare function submitPairingPin(pin: string): Promise<void>;
+export declare function getLocalNetworkPermissionState(): CastLocalNetworkPermission;
+export declare function requestLocalNetworkPermission(): Promise<CastLocalNetworkPermission>;
+export declare function addRouteListener(listener: (route: CastRoute) => void): CastSubscription;
+export declare function addReceiversListener(listener: (receivers: CastReceiver[]) => void): CastSubscription;
+export declare function addDiscoveryStateListener(listener: (state: CastDiscoveryState) => void): CastSubscription;
+export declare function addSessionDiedListener(listener: (event: CastSessionDiedEvent) => void): CastSubscription;
+export declare function addLocalNetworkPermissionListener(listener: (event: CastLocalNetworkPermissionEvent) => void): CastSubscription;
+/** Local fallback route. Useful for picker UI before discovery starts. */
+export declare function localRoute(): CastRoute;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/cast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cast/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,0BAA0B,EAC1B,+BAA+B,EAC/B,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,SAAS,EACT,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,0BAA0B,EAC1B,+BAA+B,EAC/B,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,SAAS,EACT,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,GACnB,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAkBjF,iFAAiF;AACjF,wBAAgB,qBAAqB,IAAI,YAAY,EAAE,CAEtD;AAED,sEAAsE;AACtE,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAID,MAAM,WAAW,UAAU;IACzB,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAK3D;AAID,wBAAgB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAE9C;AAED,wBAAgB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAE7C;AAED,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAID,wBAAgB,YAAY,IAAI,YAAY,EAAE,CAE7C;AAED,wBAAgB,eAAe,IAAI,SAAS,CAE3C;AAID,wBAAgB,OAAO,CACrB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9B,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAgB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAE1C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEhD;AAID,6EAA6E;AAC7E,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3D;AAID,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3D;AAID,wBAAgB,8BAA8B,IAAI,0BAA0B,CAE3E;AAED,wBAAgB,6BAA6B,IAAI,OAAO,CAAC,0BAA0B,CAAC,CAEnF;AAeD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,GACnC,gBAAgB,CAElB;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,KAAK,IAAI,GAC5C,gBAAgB,CAElB;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC5C,gBAAgB,CAElB;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAC9C,gBAAgB,CAElB;AAED,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,CAAC,KAAK,EAAE,+BAA+B,KAAK,IAAI,GACzD,gBAAgB,CAIlB;AAID,0EAA0E;AAC1E,wBAAgB,UAAU,IAAI,SAAS,CAEtC"}

package/lib/typescript/clients.d.ts

@@ -0,0 +1,9 @@
+import type { CastManager } from './CastManager.nitro';
+import type { Equalizer } from './Equalizer.nitro';
+import type { TrackPlayer } from './TrackPlayer.nitro';
+import type { Visualizer } from './Visualizer.nitro';
+export declare function getTrackPlayer(): TrackPlayer;
+export declare function getEqualizer(): Equalizer;
+export declare function getVisualizer(): Visualizer;
+export declare function getCastManager(): CastManager;
+//# sourceMappingURL=clients.d.ts.map

package/lib/typescript/clients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../src/clients.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAkBrD,wBAAgB,cAAc,IAAI,WAAW,CAK5C;AAED,wBAAgB,YAAY,IAAI,SAAS,CAKxC;AAED,wBAAgB,aAAa,IAAI,UAAU,CAK1C;AAED,wBAAgB,cAAc,IAAI,WAAW,CAK5C"}

package/lib/typescript/equalizer.d.ts

@@ -0,0 +1,45 @@
+import type { EqualizerBand, EqualizerPreset } from './types';
+/**
+ * Pure-function helper utilities for the equalizer surface. The
+ * imperative API lives on `getEqualizer()` and the React hook
+ * lives in `hooks/useEqualizer`; this module gives consumers
+ * format / range / lookup helpers that don't require a Hybrid call.
+ */
+/** Project-wide gain range. Matches the native clamp on both platforms. */
+export declare const EQ_GAIN_MIN_DB = -12;
+export declare const EQ_GAIN_MAX_DB = 12;
+/** ISO-standard centre frequencies (Hz) the cascade processes. */
+export declare const EQ_BAND_FREQUENCIES_HZ: readonly number[];
+/** Number of bands in the cascade (pinned to 10). */
+export declare const EQ_BAND_COUNT = 10;
+/**
+ * Clamp a gain (dB) to the project-wide spec range. Values
+ * outside the range round to the nearest endpoint rather than
+ * throwing — JS callers can pass slider values without explicit
+ * pre-validation.
+ */
+export declare function clampGain(dB: number): number;
+/** Sentinel name used by both platforms for the no-EQ identity preset. */
+export declare const EQ_FLAT_PRESET_NAME = "Flat";
+/** Returns true when [name] is one of the 16 built-in presets. */
+export declare function isBuiltinPreset(presets: readonly EqualizerPreset[], name: string): boolean;
+/**
+ * Build a 10-element gain array from a partial map keyed by
+ * band index. Missing entries default to 0; out-of-range indices
+ * are silently dropped. Useful when the consumer's UI tracks
+ * gains as a sparse `{ [index]: gainDb }` shape.
+ */
+export declare function gainsFromMap(map: Readonly<Record<number, number>>): number[];
+/**
+ * Find the band whose centre frequency is closest to [hz]. Used
+ * by visualisations that need to map an arbitrary frequency
+ * (e.g. an FFT bin) to the nearest cascade band.
+ */
+export declare function nearestBandIndex(hz: number): number;
+/**
+ * Snapshot a band array down to a plain `number[]` of gains in
+ * cascade order. Useful when feeding [setAllBandGains] from a
+ * UI that tracks `EqualizerBand[]` shape internally.
+ */
+export declare function gainsFromBands(bands: readonly EqualizerBand[]): number[];
+//# sourceMappingURL=equalizer.d.ts.map

package/lib/typescript/equalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equalizer.d.ts","sourceRoot":"","sources":["../../src/equalizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;GAKG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAEnD,CAAC;AAEF,qDAAqD;AACrD,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAK5C;AAED,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,SAAS,CAAC;AAE1C,kEAAkE;AAClE,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1F;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,EAAE,CAS5E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAYnD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,EAAE,CAExE"}

package/lib/typescript/hooks/index.d.ts

@@ -0,0 +1,22 @@
+export { useProgress } from './useProgress';
+export type { ProgressState } from './useProgress';
+export { usePlaybackState } from './usePlaybackState';
+export type { PlaybackStateSnapshot } from './usePlaybackState';
+export { useActiveTrack } from './useActiveTrack';
+export type { ActiveTrackSnapshot } from './useActiveTrack';
+export { useCanSkip } from './useCanSkip';
+export type { CanSkipSnapshot } from './useCanSkip';
+export { useSleepTimer } from './useSleepTimer';
+export { useBufferState } from './useBufferState';
+export { useFullyBuffered } from './useFullyBuffered';
+export { useEqualizer } from './useEqualizer';
+export type { UseEqualizerResult } from './useEqualizer';
+export { useVisualizerState } from './useVisualizerState';
+export type { VisualizerState } from './useVisualizerState';
+export { useLookaheadCache } from './useLookaheadCache';
+export type { UseLookaheadCacheResult } from './useLookaheadCache';
+export { useNowPlayingFormat } from './useNowPlayingFormat';
+export { useCast } from './useCast';
+export type { CastSnapshot } from './useCast';
+export { useAudioRoute } from './useAudioRoute';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/lib/typescript/hooks/useActiveTrack.d.ts

@@ -0,0 +1,21 @@
+import type { TrackItem, TrackChangeReason } from '../types';
+export interface ActiveTrackSnapshot {
+    track: TrackItem | undefined;
+    /** -1 when the queue is empty. */
+    index: number;
+    /** Why the track last changed. `'queue-replaced'` for the initial render. */
+    reason: TrackChangeReason;
+}
+/**
+ * Subscribes to native `onTrackChange` updates.
+ *
+ * The first-render seed reads `getQueue()` and `getCurrentTrackIndex()`
+ * separately — the pair is not atomic against a concurrent queue
+ * mutation on either platform, so the seed can briefly observe the
+ * new list with the old index (or vice versa). Self-healing: the
+ * next `onTrackChange` event delivers a consistent
+ * `(track, index, reason)` triple. Consumers needing an atomic
+ * snapshot should wait for the first listener fire.
+ */
+export declare function useActiveTrack(): ActiveTrackSnapshot;
+//# sourceMappingURL=useActiveTrack.d.ts.map

package/lib/typescript/hooks/useActiveTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActiveTrack.d.ts","sourceRoot":"","sources":["../../../src/hooks/useActiveTrack.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7D,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,SAAS,GAAG,SAAS,CAAC;IAC7B,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,IAAI,mBAAmB,CAyBpD"}

package/lib/typescript/hooks/useAudioRoute.d.ts

@@ -0,0 +1,13 @@
+import type { AudioRoute } from '../types';
+/**
+ * Subscribe to the active audio output. Returns the current `AudioRoute`
+ * (kind + name + identifier + isExternal + isSystemManaged) and updates
+ * on every system route change — BT pair/unpair, wired plug/unplug,
+ * AirPlay route swap, Chromecast session activate/deactivate.
+ *
+ * Independent of cast discovery: reading does not trigger a scan. The
+ * picker can show "currently playing on AirPods (Bluetooth)" while
+ * cast discovery is idle.
+ */
+export declare function useAudioRoute(): AudioRoute;
+//# sourceMappingURL=useAudioRoute.d.ts.map

package/lib/typescript/hooks/useAudioRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAudioRoute.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAudioRoute.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAU3C;;;;;;;;;GASG;AACH,wBAAgB,aAAa,IAAI,UAAU,CA4B1C"}

package/lib/typescript/hooks/useBufferState.d.ts

@@ -0,0 +1,18 @@
+import type { BufferState } from '../types';
+/**
+ * Subscribes to native `onBufferStateChange` and exposes the current discrete
+ * buffer state for the active track (`'empty' | 'buffering' | 'stalled' | 'full'`). Driven by
+ * the platform's native buffer signals rather than the progress tick, so a
+ * loading / stall indicator reacts immediately.
+ *
+ * ```tsx
+ * const buffer = useBufferState();
+ * {buffer !== 'full' && <Spinner />}
+ * ```
+ *
+ * `'full'` means playback can proceed smoothly from the current position, not
+ * that the whole track is downloaded — for buffered-ahead seconds read
+ * `useProgress().buffered`.
+ */
+export declare function useBufferState(): BufferState;
+//# sourceMappingURL=useBufferState.d.ts.map

package/lib/typescript/hooks/useBufferState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBufferState.d.ts","sourceRoot":"","sources":["../../../src/hooks/useBufferState.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAe5C"}

package/lib/typescript/hooks/useCanSkip.d.ts

@@ -0,0 +1,43 @@
+export interface CanSkipSnapshot {
+    /**
+     * Whether the user-facing Next button should be enabled. True when
+     * there's a next track to skip to under the current repeat mode:
+     * false at the last track in `'off'` and `'track'` (no wrap), always
+     * true under `'queue'` (wraps). `'track'` (repeat-one) navigates
+     * exactly like `'off'`; only natural auto-advance replays the
+     * current track.
+     */
+    canSkipNext: boolean;
+    /**
+     * Whether the user-facing Previous button should be enabled.
+     * Symmetric with `canSkipNext` — true when there's a previous track
+     * to skip to under the current repeat mode (false at index 0 in
+     * `'off'` and `'track'` — no wrap; true under `'queue'` since it
+     * wraps). Apps that want the Apple-Music-style "tap Previous
+     * restarts current when position > 3s" UX implement that themselves
+     * in their button handler.
+     */
+    canSkipPrevious: boolean;
+}
+/**
+ * Subscribes to native `onSkipCapabilityChange` updates. Bind the
+ * returned booleans to the `disabled` prop of skip-next / skip-prev
+ * buttons:
+ *
+ * ```tsx
+ * const { canSkipNext, canSkipPrevious } = useCanSkip();
+ * <Button disabled={!canSkipPrevious} onPress={() => player.skipToPrevious()} />
+ * <Button disabled={!canSkipNext} onPress={() => player.skipToNext()} />
+ * ```
+ *
+ * The native side recomputes whenever queue, current index, repeat
+ * mode, or shuffle changes, with dedup so the listener fires only on
+ * actual flips. The first render seeds synchronously via
+ * `getCanSkipNext` / `getCanSkipPrevious` to avoid the "buttons flash
+ * disabled then enabled" UX on mount; the listener also auto-fires
+ * on subscribe (Media3 `onAvailableCommandsChanged` semantic). When
+ * the auto-fire payload matches the seed, the dedup ref below
+ * suppresses the redundant re-render.
+ */
+export declare function useCanSkip(): CanSkipSnapshot;
+//# sourceMappingURL=useCanSkip.d.ts.map

package/lib/typescript/hooks/useCanSkip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanSkip.d.ts","sourceRoot":"","sources":["../../../src/hooks/useCanSkip.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;;;;;;;OAQG;IACH,eAAe,EAAE,OAAO,CAAC;CAC1B;AAOD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,IAAI,eAAe,CAyC5C"}

package/lib/typescript/hooks/useCast.d.ts

@@ -0,0 +1,32 @@
+import { type CastLocalNetworkPermission, type CastProtocol, type CastReceiver, type CastRoute, type CastSessionDiedEvent } from '../cast';
+export interface CastSnapshot {
+    /** Protocols compiled into the current build (AirPlay / Chromecast). */
+    supportedProtocols: CastProtocol[];
+    /** `true` if at least one cast protocol is available on the device. */
+    isAvailable: boolean;
+    /** Live receiver list, replayed once synchronously on subscribe. */
+    receivers: CastReceiver[];
+    /** Currently active route — falls back to a synthesised local route. */
+    route: CastRoute;
+    /** `true` while at least one backend is actively scanning. */
+    isDiscovering: boolean;
+    /**
+     * Last `onSessionDied` event, or `null` until one arrives. Consumers
+     * clear by re-reading state after surfacing a banner.
+     */
+    lastSessionDied: CastSessionDiedEvent | null;
+    /** iOS Local Network permission state; `'granted'` on Android. */
+    permission: CastLocalNetworkPermission;
+}
+/**
+ * Aggregated cast state for picker UIs. Subscribes to all five Cast
+ * event streams + reads the initial snapshot synchronously on mount.
+ *
+ * Returns a single object so consumers can pattern-match without
+ * threading five hook calls through their render. Consumers needing
+ * just one slice (e.g. only `receivers`) should still prefer this
+ * hook over the underlying listeners — the lib already debounces +
+ * coalesces updates.
+ */
+export declare function useCast(): CastSnapshot;
+//# sourceMappingURL=useCast.d.ts.map

package/lib/typescript/hooks/useCast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCast.d.ts","sourceRoot":"","sources":["../../../src/hooks/useCast.ts"],"names":[],"mappings":"AACA,OAAO,EAYL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,oBAAoB,EAC1B,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,kBAAkB,EAAE,YAAY,EAAE,CAAC;IACnC,uEAAuE;IACvE,WAAW,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,wEAAwE;IACxE,KAAK,EAAE,SAAS,CAAC;IACjB,8DAA8D;IAC9D,aAAa,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,eAAe,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC7C,kEAAkE;IAClE,UAAU,EAAE,0BAA0B,CAAC;CACxC;AAYD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,IAAI,YAAY,CA4DtC"}

package/lib/typescript/hooks/useEqualizer.d.ts

@@ -0,0 +1,20 @@
+import type { EqualizerBand, EqualizerPreset } from '../types';
+export interface UseEqualizerResult {
+    enabled: boolean;
+    bands: EqualizerBand[];
+    presets: EqualizerPreset[];
+    setEnabled: (enabled: boolean) => Promise<void>;
+    setBandGain: (index: number, gainDb: number) => Promise<void>;
+    setAllBandGains: (gains: number[]) => Promise<void>;
+    applyPreset: (name: string) => Promise<void>;
+    saveCustomPreset: (name: string) => Promise<void>;
+    deleteCustomPreset: (name: string) => Promise<void>;
+    reset: () => Promise<void>;
+}
+/**
+ * Subscribes to Equalizer band-change events and exposes imperative setters.
+ * Initial state is pulled synchronously on mount so consumers don't flash
+ * empty bands.
+ */
+export declare function useEqualizer(): UseEqualizerResult;
+//# sourceMappingURL=useEqualizer.d.ts.map

package/lib/typescript/hooks/useEqualizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEqualizer.d.ts","sourceRoot":"","sources":["../../../src/hooks/useEqualizer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE/D,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,kBAAkB,CAwFjD"}

package/lib/typescript/hooks/useFullyBuffered.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Subscribes to native `onFullyBufferedChange` and returns whether the active
+ * track has fully downloaded (`true` once the whole media is buffered). Distinct
+ * from `useBufferState() === 'full'` (which is "enough buffered to keep up") —
+ * a track can keep up while still downloading. Use it to push a buffered bar to
+ * 100% or enable a full-length scrubber once nothing is left to transfer.
+ *
+ * ```tsx
+ * const fullyBuffered = useFullyBuffered();
+ * ```
+ *
+ * Always `false` for a live / unknown-length stream that never completes.
+ */
+export declare function useFullyBuffered(): boolean;
+//# sourceMappingURL=useFullyBuffered.d.ts.map

package/lib/typescript/hooks/useFullyBuffered.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFullyBuffered.d.ts","sourceRoot":"","sources":["../../../src/hooks/useFullyBuffered.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAe1C"}

package/lib/typescript/hooks/useLookaheadCache.d.ts

@@ -0,0 +1,13 @@
+import type { CacheStatus, LookaheadCacheConfig } from '../types';
+export interface UseLookaheadCacheResult {
+    status: CacheStatus;
+    setConfig: (config: LookaheadCacheConfig) => Promise<void>;
+    clear: () => Promise<void>;
+}
+/**
+ * Subscribes to lookahead-cache status updates and exposes imperative
+ * setters for runtime reconfiguration (e.g. switch from wifi → cellular
+ * and drop the lookahead count).
+ */
+export declare function useLookaheadCache(): UseLookaheadCacheResult;
+//# sourceMappingURL=useLookaheadCache.d.ts.map

package/lib/typescript/hooks/useLookaheadCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLookaheadCache.d.ts","sourceRoot":"","sources":["../../../src/hooks/useLookaheadCache.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAElE,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAcD;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,uBAAuB,CA0B3D"}

package/lib/typescript/hooks/useNowPlayingFormat.d.ts

@@ -0,0 +1,18 @@
+import type { NowPlayingFormat } from '../types';
+/**
+ * Subscribes to native `onNowPlayingFormatChange` updates.
+ *
+ * Returns `null` until the native side has resolved the active
+ * track's audio format. iOS requires `await asset.load(.tracks,
+ * .formatDescriptions, .estimatedDataRate)` per item; Android lands
+ * the data via `Player.Listener.onTracksChanged(Tracks)` before
+ * STATE_READY. Either way the format arrives moments after the
+ * `onTrackChange` event for that item — render against `null`
+ * during the gap.
+ *
+ * The first-render seed reads `getNowPlayingFormat()` synchronously
+ * so a tab re-mount mid-playback doesn't transiently flash `null`
+ * if the format is already known.
+ */
+export declare function useNowPlayingFormat(): NowPlayingFormat | null;
+//# sourceMappingURL=useNowPlayingFormat.d.ts.map

package/lib/typescript/hooks/useNowPlayingFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNowPlayingFormat.d.ts","sourceRoot":"","sources":["../../../src/hooks/useNowPlayingFormat.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,IAAI,CAuB7D"}

package/lib/typescript/hooks/usePlaybackState.d.ts

@@ -0,0 +1,9 @@
+import type { PlayerState, StateChangeReason } from '../types';
+export interface PlaybackStateSnapshot {
+    state: PlayerState;
+    /** Why the state last changed. `'system'` for the initial render. */
+    reason: StateChangeReason;
+}
+/** Subscribes to native `onStateChange` updates. */
+export declare function usePlaybackState(): PlaybackStateSnapshot;
+//# sourceMappingURL=usePlaybackState.d.ts.map

package/lib/typescript/hooks/usePlaybackState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePlaybackState.d.ts","sourceRoot":"","sources":["../../../src/hooks/usePlaybackState.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE/D,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,WAAW,CAAC;IACnB,qEAAqE;IACrE,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAID,oDAAoD;AACpD,wBAAgB,gBAAgB,IAAI,qBAAqB,CAoBxD"}

package/lib/typescript/hooks/useProgress.d.ts

@@ -0,0 +1,15 @@
+export interface ProgressState {
+    /** Seconds from start of the current track. 0 when no track active. */
+    position: number;
+    /** Seconds. 0 when duration is unknown or no track active. */
+    duration: number;
+    /** Seconds buffered ahead of `position`. 0 when unknown. */
+    buffered: number;
+}
+/**
+ * Subscribes to native `onProgress` updates. Progress is driven by a native
+ * periodic timer (see NOTES.md §5), so this hook stays accurate even when
+ * the app is backgrounded.
+ */
+export declare function useProgress(): ProgressState;
+//# sourceMappingURL=useProgress.d.ts.map

package/lib/typescript/hooks/useProgress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useProgress.d.ts","sourceRoot":"","sources":["../../../src/hooks/useProgress.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAID;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,aAAa,CAgB3C"}

package/lib/typescript/hooks/useSleepTimer.d.ts

@@ -0,0 +1,26 @@
+import type { SleepTimerState } from '../types';
+/**
+ * Subscribes to native `onSleepTimerChange` and exposes the current sleep-timer
+ * state. `remainingSeconds` is recomputed locally once a second from the
+ * wall-clock `endsAtEpochMs`, so a countdown label stays live — the native side
+ * emits only on arm / clear / end-of-track conversion / fire, not on every tick.
+ *
+ * ```tsx
+ * const timer = useSleepTimer();
+ * // arm: player.setSleepTimer(15 * 60) or player.setSleepTimerToTrackEnd()
+ * {timer.active && (
+ *   <Text>
+ *     {timer.remainingSeconds === undefined
+ *       ? 'Stopping at end of track'
+ *       : `Sleeping in ${timer.remainingSeconds}s`}
+ *   </Text>
+ * )}
+ * ```
+ *
+ * When end-of-track is armed, `endsAtEpochMs` / `remainingSeconds` are absent
+ * while `endOfTrack` is true. Once the current track enters the tail window the
+ * timer converts to a concrete countdown: `endOfTrack` flips to false and
+ * `remainingSeconds` starts counting down.
+ */
+export declare function useSleepTimer(): SleepTimerState;
+//# sourceMappingURL=useSleepTimer.d.ts.map

package/lib/typescript/hooks/useSleepTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSleepTimer.d.ts","sourceRoot":"","sources":["../../../src/hooks/useSleepTimer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAUhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,IAAI,eAAe,CA2B/C"}

package/lib/typescript/hooks/useVisualizerState.d.ts

@@ -0,0 +1,40 @@
+import type { VisualizerConfig, VisualizerErrorReason } from '../types';
+export interface VisualizerState {
+    /**
+     * Float32Array view over the FFT magnitudes. Length = `fftSize / 2`.
+     * `null` until the first frame lands.
+     */
+    fft: Float32Array | null;
+    /**
+     * Float32Array view over the raw PCM samples. Length = `fftSize`.
+     * `null` unless the subscription was opened with
+     * `config.includeSamples === true` AND a frame has landed.
+     */
+    samples: Float32Array | null;
+    /** Stream sample rate in Hz, or 0 before any frame lands. */
+    sampleRate: number;
+    /** True once any frame has landed and no error reason is active. */
+    available: boolean;
+    /** Last-reported error reason, or `null` if frames are flowing. */
+    reason: VisualizerErrorReason | null;
+}
+/**
+ * Subscribe to the Visualizer for the lifetime of the hook + surface
+ * the latest frame as plain React state at `sampleRateHz` cadence
+ * (default 30 Hz).
+ *
+ * The native bridge fires frames at `config.updateIntervalMs` (the
+ * audio render thread cadence — typically 60+ Hz). Throttling to
+ * 30 Hz on the React side keeps re-render pressure manageable; ~25
+ * FPS is enough for the visualizer aesthetic and renders smoothly
+ * on 60 Hz screens.
+ *
+ * The subscription re-creates only on primitive `config` field
+ * changes — passing an inline literal each render is safe.
+ *
+ * Effects cleanly: when the hook unmounts, the disposer runs; when
+ * no other subscribers are live, the native layer pauses FFT
+ * processing.
+ */
+export declare function useVisualizerState(config: VisualizerConfig, sampleRateHz?: number): VisualizerState;
+//# sourceMappingURL=useVisualizerState.d.ts.map

package/lib/typescript/hooks/useVisualizerState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVisualizerState.d.ts","sourceRoot":"","sources":["../../../src/hooks/useVisualizerState.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,qBAAqB,EAEtB,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,GAAG,EAAE,YAAY,GAAG,IAAI,CAAC;IACzB;;;;OAIG;IACH,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,SAAS,EAAE,OAAO,CAAC;IACnB,mEAAmE;IACnE,MAAM,EAAE,qBAAqB,GAAG,IAAI,CAAC;CACtC;AAUD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,gBAAgB,EACxB,YAAY,GAAE,MAAW,GACxB,eAAe,CA+DjB"}

package/lib/typescript/index.d.ts

@@ -0,0 +1,14 @@
+export type { TrackPlayer } from './TrackPlayer.nitro';
+export type { Equalizer } from './Equalizer.nitro';
+export type { Visualizer } from './Visualizer.nitro';
+export type { CastManager } from './CastManager.nitro';
+export type { TrackItem, PlayerConfig, PlayerState, BufferState, PlaybackMode, PlaybackModeKind, RepeatMode, RemoteSkipMode, RemoteControlOptions, StateChangeReason, TrackChangeReason, TrackSource, PlayerProgress, PlaybackError, PlaybackErrorCode, ShuffleResult, SkipCapability, SleepTimerState, NowPlayingFormat, AudioCodec, AudioContainer, LookaheadCacheConfig, EvictionPolicy, CacheStatus, MediaSearchRequest, MediaSearchType, MediaSearchOrigin, MediaSearchReference, MediaSearchRepeatMode, MediaSearchReleaseDateRange, MediaSearchQueueLocation, BrowseItem, BrowseSection, BrowseSnapshot, ServiceReadyReason, EqualizerBand, EqualizerPreset, ReplayGainMode, PitchCorrectionMode, VisualizerConfig, VisualizerFftSize, VisualizerFrame, VisualizerErrorReason, CastProtocol, CastStreamingModel, CastDeviceKind, CastSessionEndReason, CastLocalNetworkPermission, CastReceiverCapabilities, CastReceiver, CastRoute, CastDiscoveryState, CastSessionDiedEvent, CastLocalNetworkPermissionEvent, CastConnectOptions, AudioRouteKind, AudioRoute, } from './types';
+export { getCastManager, getEqualizer, getTrackPlayer, getVisualizer } from './clients';
+export { registerPlaybackService, unregisterPlaybackService, } from './playbackService';
+export type { PlaybackServiceHandler, PlaybackServiceFactory, } from './playbackService';
+export { crossfadeDurationBounds } from './types';
+export { SectionIcon } from './types';
+export { EQ_BAND_COUNT, EQ_BAND_FREQUENCIES_HZ, EQ_FLAT_PRESET_NAME, EQ_GAIN_MAX_DB, EQ_GAIN_MIN_DB, clampGain, gainsFromBands, gainsFromMap, isBuiltinPreset, nearestBandIndex, } from './equalizer';
+export * from './hooks';
+export * as Cast from './cast';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGvD,YAAY,EAEV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,UAAU,EACV,cAAc,EAEd,oBAAoB,EACpB,cAAc,EACd,WAAW,EAEX,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,2BAA2B,EAC3B,wBAAwB,EACxB,UAAU,EACV,aAAa,EACb,cAAc,EACd,kBAAkB,EAElB,aAAa,EACb,eAAe,EAEf,cAAc,EAEd,mBAAmB,EAEnB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EAErB,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,oBAAoB,EACpB,0BAA0B,EAC1B,wBAAwB,EACxB,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,oBAAoB,EACpB,+BAA+B,EAC/B,kBAAkB,EAElB,cAAc,EACd,UAAU,GACX,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAKxF,OAAO,EACL,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAKlD,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAKtC,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,SAAS,EACT,cAAc,EACd,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAGrB,cAAc,SAAS,CAAC;AAKxB,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}