audio-channel-queue 1.6.0 → 1.8.0

package/dist/info.js

@@ -7,7 +7,8 @@ exports.offAudioResume = exports.offAudioPause = exports.onAudioResume = exports
 const utils_1 = require("./utils");
 const events_1 = require("./events");
 /**
- * Global array of extended audio queue channels
+ * Global array to store audio channels with their queues and callback management
+ * Each channel maintains its own audio queue and event callback sets
  */
 exports.audioChannels = [];
 /**
@@ -86,6 +87,7 @@ const onAudioProgress = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
             audioPauseCallbacks: new Set(),
             audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
@@ -154,6 +156,7 @@ const onQueueChange = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
             audioPauseCallbacks: new Set(),
             audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
@@ -202,6 +205,7 @@ const onAudioStart = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
             audioPauseCallbacks: new Set(),
             audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
@@ -237,6 +241,7 @@ const onAudioComplete = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
             audioPauseCallbacks: new Set(),
             audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
@@ -270,6 +275,7 @@ const onAudioPause = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
             audioPauseCallbacks: new Set(),
             audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),
@@ -303,6 +309,7 @@ const onAudioResume = (channelNumber, callback) => {
     if (!exports.audioChannels[channelNumber]) {
         exports.audioChannels[channelNumber] = {
             audioCompleteCallbacks: new Set(),
+            audioErrorCallbacks: new Set(),
             audioPauseCallbacks: new Set(),
             audioResumeCallbacks: new Set(),
             audioStartCallbacks: new Set(),

package/dist/pause.d.ts

@@ -1,6 +1,77 @@
 /**
  * @fileoverview Pause and resume management functions for the audio-channel-queue package
  */
+import { FadeType } from './types';
+/**
+ * Pauses the currently playing audio in a specific channel with smooth volume fade
+ * @param fadeType - Type of fade transition to apply
+ * @param channelNumber - The channel number to pause (defaults to 0)
+ * @returns Promise that resolves when the pause and fade are complete
+ * @example
+ * ```typescript
+ * await pauseWithFade(FadeType.Gentle, 0); // Pause with gentle fade out over 800ms
+ * await pauseWithFade(FadeType.Dramatic, 1); // Pause with dramatic fade out over 800ms
+ * await pauseWithFade(FadeType.Linear, 2); // Linear pause with 800ms fade
+ * ```
+ */
+export declare const pauseWithFade: (fadeType?: FadeType, channelNumber?: number) => Promise<void>;
+/**
+ * Resumes the currently paused audio in a specific channel with smooth volume fade
+ * Uses the complementary fade curve automatically based on the pause fade type, or allows override
+ * @param fadeType - Optional fade type to override the stored fade type from pause
+ * @param channelNumber - The channel number to resume (defaults to 0)
+ * @returns Promise that resolves when the resume and fade are complete
+ * @example
+ * ```typescript
+ * await resumeWithFade(); // Resume with automatically paired fade curve from pause
+ * await resumeWithFade(FadeType.Dramatic, 0); // Override with dramatic fade
+ * await resumeWithFade(FadeType.Linear); // Override with linear fade on default channel
+ * ```
+ */
+export declare const resumeWithFade: (fadeType?: FadeType, channelNumber?: number) => Promise<void>;
+/**
+ * Toggles pause/resume state for a specific channel with integrated fade
+ * @param fadeType - Type of fade transition to apply when pausing
+ * @param channelNumber - The channel number to toggle (defaults to 0)
+ * @returns Promise that resolves when the toggle and fade are complete
+ * @example
+ * ```typescript
+ * await togglePauseWithFade(FadeType.Gentle, 0); // Toggle with gentle fade
+ * ```
+ */
+export declare const togglePauseWithFade: (fadeType?: FadeType, channelNumber?: number) => Promise<void>;
+/**
+ * Pauses all currently playing audio across all channels with smooth volume fade
+ * @param fadeType - Type of fade transition to apply to all channels
+ * @returns Promise that resolves when all channels are paused and faded
+ * @example
+ * ```typescript
+ * await pauseAllWithFade('dramatic'); // Pause everything with dramatic fade
+ * ```
+ */
+export declare const pauseAllWithFade: (fadeType?: FadeType) => Promise<void>;
+/**
+ * Resumes all currently paused audio across all channels with smooth volume fade
+ * Uses automatically paired fade curves based on each channel's pause fade type
+ * @returns Promise that resolves when all channels are resumed and faded
+ * @example
+ * ```typescript
+ * await resumeAllWithFade(); // Resume everything with paired fade curves
+ * ```
+ */
+export declare const resumeAllWithFade: () => Promise<void>;
+/**
+ * Toggles pause/resume state for all channels with integrated fade
+ * If any channels are playing, all will be paused with fade
+ * If all channels are paused, all will be resumed with fade
+ * @param fadeType - Type of fade transition to apply when pausing
+ * @returns Promise that resolves when all toggles and fades are complete
+ * @example
+ * ```typescript
+ * await togglePauseAllWithFade('gentle'); // Global toggle with gentle fade
+ * ```
+ */
+export declare const togglePauseAllWithFade: (fadeType?: FadeType) => Promise<void>;
 /**
  * Pauses the currently playing audio in a specific channel
  * @param channelNumber - The channel number to pause (defaults to 0)

package/dist/pause.js

@@ -12,10 +12,213 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.togglePauseAllChannels = exports.getAllChannelsPauseState = exports.isChannelPaused = exports.resumeAllChannels = exports.pauseAllChannels = exports.togglePauseChannel = exports.resumeChannel = exports.pauseChannel = void 0;
+exports.togglePauseAllChannels = exports.getAllChannelsPauseState = exports.isChannelPaused = exports.resumeAllChannels = exports.pauseAllChannels = exports.togglePauseChannel = exports.resumeChannel = exports.pauseChannel = exports.togglePauseAllWithFade = exports.resumeAllWithFade = exports.pauseAllWithFade = exports.togglePauseWithFade = exports.resumeWithFade = exports.pauseWithFade = void 0;
+const types_1 = require("./types");
 const info_1 = require("./info");
 const utils_1 = require("./utils");
 const events_1 = require("./events");
+const volume_1 = require("./volume");
+/**
+ * Predefined fade configurations for different transition types
+ */
+const FADE_CONFIGS = {
+    [types_1.FadeType.Linear]: { duration: 800, pauseCurve: types_1.EasingType.Linear, resumeCurve: types_1.EasingType.Linear },
+    [types_1.FadeType.Gentle]: { duration: 800, pauseCurve: types_1.EasingType.EaseOut, resumeCurve: types_1.EasingType.EaseIn },
+    [types_1.FadeType.Dramatic]: { duration: 800, pauseCurve: types_1.EasingType.EaseIn, resumeCurve: types_1.EasingType.EaseOut }
+};
+/**
+ * Gets the current volume for a channel, accounting for synchronous state
+ * @param channelNumber - The channel number
+ * @returns Current volume level (0-1)
+ */
+const getChannelVolumeSync = (channelNumber) => {
+    const channel = info_1.audioChannels[channelNumber];
+    return (channel === null || channel === void 0 ? void 0 : channel.volume) || 1.0;
+};
+/**
+ * Sets the channel volume synchronously in internal state
+ * @param channelNumber - The channel number
+ * @param volume - Volume level (0-1)
+ */
+const setChannelVolumeSync = (channelNumber, volume) => {
+    const channel = info_1.audioChannels[channelNumber];
+    if (channel) {
+        channel.volume = volume;
+        if (channel.queue.length > 0) {
+            channel.queue[0].volume = volume;
+        }
+    }
+};
+/**
+ * Pauses the currently playing audio in a specific channel with smooth volume fade
+ * @param fadeType - Type of fade transition to apply
+ * @param channelNumber - The channel number to pause (defaults to 0)
+ * @returns Promise that resolves when the pause and fade are complete
+ * @example
+ * ```typescript
+ * await pauseWithFade(FadeType.Gentle, 0); // Pause with gentle fade out over 800ms
+ * await pauseWithFade(FadeType.Dramatic, 1); // Pause with dramatic fade out over 800ms
+ * await pauseWithFade(FadeType.Linear, 2); // Linear pause with 800ms fade
+ * ```
+ */
+const pauseWithFade = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (fadeType = types_1.FadeType.Gentle, channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (!channel || channel.queue.length === 0)
+        return;
+    const currentAudio = channel.queue[0];
+    // Don't pause if already paused or ended
+    if (currentAudio.paused || currentAudio.ended)
+        return;
+    const config = FADE_CONFIGS[fadeType];
+    const originalVolume = getChannelVolumeSync(channelNumber);
+    // Store fade state for resumeWithFade to use
+    channel.fadeState = {
+        originalVolume,
+        fadeType,
+        isPaused: true
+    };
+    if (config.duration === 0) {
+        // Instant pause
+        yield (0, exports.pauseChannel)(channelNumber);
+        return;
+    }
+    // Fade to 0 with pause curve, then pause
+    yield (0, volume_1.transitionVolume)(channelNumber, 0, config.duration, config.pauseCurve);
+    yield (0, exports.pauseChannel)(channelNumber);
+    // Reset volume to original for resume (synchronously to avoid state issues)
+    setChannelVolumeSync(channelNumber, originalVolume);
+});
+exports.pauseWithFade = pauseWithFade;
+/**
+ * Resumes the currently paused audio in a specific channel with smooth volume fade
+ * Uses the complementary fade curve automatically based on the pause fade type, or allows override
+ * @param fadeType - Optional fade type to override the stored fade type from pause
+ * @param channelNumber - The channel number to resume (defaults to 0)
+ * @returns Promise that resolves when the resume and fade are complete
+ * @example
+ * ```typescript
+ * await resumeWithFade(); // Resume with automatically paired fade curve from pause
+ * await resumeWithFade(FadeType.Dramatic, 0); // Override with dramatic fade
+ * await resumeWithFade(FadeType.Linear); // Override with linear fade on default channel
+ * ```
+ */
+const resumeWithFade = (fadeType_1, ...args_1) => __awaiter(void 0, [fadeType_1, ...args_1], void 0, function* (fadeType, channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (!channel || channel.queue.length === 0)
+        return;
+    const fadeState = channel.fadeState;
+    if (!fadeState || !fadeState.isPaused) {
+        // Fall back to regular resume if no fade state
+        yield (0, exports.resumeChannel)(channelNumber);
+        return;
+    }
+    // Use provided fadeType or fall back to stored fadeType from pause
+    const effectiveFadeType = fadeType || fadeState.fadeType;
+    const config = FADE_CONFIGS[effectiveFadeType];
+    if (config.duration === 0) {
+        // Instant resume
+        yield (0, exports.resumeChannel)(channelNumber);
+        fadeState.isPaused = false;
+        return;
+    }
+    // Set volume to 0, resume, then fade to original with resume curve
+    setChannelVolumeSync(channelNumber, 0);
+    yield (0, exports.resumeChannel)(channelNumber);
+    yield (0, volume_1.transitionVolume)(channelNumber, fadeState.originalVolume, config.duration, config.resumeCurve);
+    fadeState.isPaused = false;
+});
+exports.resumeWithFade = resumeWithFade;
+/**
+ * Toggles pause/resume state for a specific channel with integrated fade
+ * @param fadeType - Type of fade transition to apply when pausing
+ * @param channelNumber - The channel number to toggle (defaults to 0)
+ * @returns Promise that resolves when the toggle and fade are complete
+ * @example
+ * ```typescript
+ * await togglePauseWithFade(FadeType.Gentle, 0); // Toggle with gentle fade
+ * ```
+ */
+const togglePauseWithFade = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (fadeType = types_1.FadeType.Gentle, channelNumber = 0) {
+    const channel = info_1.audioChannels[channelNumber];
+    if (!channel || channel.queue.length === 0)
+        return;
+    const currentAudio = channel.queue[0];
+    if (currentAudio.paused) {
+        yield (0, exports.resumeWithFade)(undefined, channelNumber);
+    }
+    else {
+        yield (0, exports.pauseWithFade)(fadeType, channelNumber);
+    }
+});
+exports.togglePauseWithFade = togglePauseWithFade;
+/**
+ * Pauses all currently playing audio across all channels with smooth volume fade
+ * @param fadeType - Type of fade transition to apply to all channels
+ * @returns Promise that resolves when all channels are paused and faded
+ * @example
+ * ```typescript
+ * await pauseAllWithFade('dramatic'); // Pause everything with dramatic fade
+ * ```
+ */
+const pauseAllWithFade = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (fadeType = types_1.FadeType.Gentle) {
+    const pausePromises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        pausePromises.push((0, exports.pauseWithFade)(fadeType, index));
+    });
+    yield Promise.all(pausePromises);
+});
+exports.pauseAllWithFade = pauseAllWithFade;
+/**
+ * Resumes all currently paused audio across all channels with smooth volume fade
+ * Uses automatically paired fade curves based on each channel's pause fade type
+ * @returns Promise that resolves when all channels are resumed and faded
+ * @example
+ * ```typescript
+ * await resumeAllWithFade(); // Resume everything with paired fade curves
+ * ```
+ */
+const resumeAllWithFade = () => __awaiter(void 0, void 0, void 0, function* () {
+    const resumePromises = [];
+    info_1.audioChannels.forEach((_channel, index) => {
+        resumePromises.push((0, exports.resumeWithFade)(undefined, index));
+    });
+    yield Promise.all(resumePromises);
+});
+exports.resumeAllWithFade = resumeAllWithFade;
+/**
+ * Toggles pause/resume state for all channels with integrated fade
+ * If any channels are playing, all will be paused with fade
+ * If all channels are paused, all will be resumed with fade
+ * @param fadeType - Type of fade transition to apply when pausing
+ * @returns Promise that resolves when all toggles and fades are complete
+ * @example
+ * ```typescript
+ * await togglePauseAllWithFade('gentle'); // Global toggle with gentle fade
+ * ```
+ */
+const togglePauseAllWithFade = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (fadeType = types_1.FadeType.Gentle) {
+    let hasPlayingChannel = false;
+    // Check if any channel is currently playing
+    for (let i = 0; i < info_1.audioChannels.length; i++) {
+        const channel = info_1.audioChannels[i];
+        if (channel && channel.queue.length > 0) {
+            const currentAudio = channel.queue[0];
+            if (!currentAudio.paused && !currentAudio.ended) {
+                hasPlayingChannel = true;
+                break;
+            }
+        }
+    }
+    // If any channel is playing, pause all with fade
+    // If no channels are playing, resume all with fade
+    if (hasPlayingChannel) {
+        yield (0, exports.pauseAllWithFade)(fadeType);
+    }
+    else {
+        yield (0, exports.resumeAllWithFade)();
+    }
+});
+exports.togglePauseAllWithFade = togglePauseAllWithFade;
 /**
  * Pauses the currently playing audio in a specific channel
  * @param channelNumber - The channel number to pause (defaults to 0)
@@ -55,7 +258,7 @@ const resumeChannel = (...args_1) => __awaiter(void 0, [...args_1], void 0, func
     const channel = info_1.audioChannels[channelNumber];
     if (channel && channel.queue.length > 0) {
         const currentAudio = channel.queue[0];
-        // Only resume if both the channel is marked as paused AND the audio element is actually paused
+        // Only resume if both the channel is marked as paused AND the audio element is actually paused AND not ended
         if (channel.isPaused && currentAudio.paused && !currentAudio.ended) {
             yield currentAudio.play();
             channel.isPaused = false;

package/dist/types.d.ts

@@ -26,7 +26,7 @@ export interface VolumeConfig {
     /** Duration in milliseconds for volume restore transition (defaults to 500ms) */
     restoreTransitionDuration?: number;
     /** Easing function for volume transitions (defaults to 'ease-out') */
-    transitionEasing?: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
+    transitionEasing?: EasingType;
 }
 /**
  * Audio file configuration for queueing
@@ -159,25 +159,98 @@ export type AudioPauseCallback = (channelNumber: number, audioInfo: AudioInfo) =
  */
 export type AudioResumeCallback = (channelNumber: number, audioInfo: AudioInfo) => void;
 /**
- * Extended audio queue channel with event callback management and additional features
- */
-export type ExtendedAudioQueueChannel = AudioQueueChannel & {
-    /** Set of callbacks for audio completion events */
-    audioCompleteCallbacks?: Set<AudioCompleteCallback>;
-    /** Set of callbacks for audio pause events */
-    audioPauseCallbacks?: Set<AudioPauseCallback>;
-    /** Set of callbacks for audio resume events */
-    audioResumeCallbacks?: Set<AudioResumeCallback>;
-    /** Set of callbacks for audio start events */
-    audioStartCallbacks?: Set<AudioStartCallback>;
-    /** Whether the current audio in this channel is paused */
+ * Information about an audio error that occurred
+ */
+export interface AudioErrorInfo {
+    channelNumber: number;
+    src: string;
+    fileName: string;
+    error: Error;
+    errorType: 'network' | 'decode' | 'unsupported' | 'permission' | 'abort' | 'timeout' | 'unknown';
+    timestamp: number;
+    retryAttempt?: number;
+    remainingInQueue: number;
+}
+/**
+ * Configuration for automatic retry behavior when audio fails to load or play
+ */
+export interface RetryConfig {
+    enabled: boolean;
+    maxRetries: number;
+    baseDelay: number;
+    exponentialBackoff: boolean;
+    timeoutMs: number;
+    fallbackUrls?: string[];
+    skipOnFailure: boolean;
+}
+/**
+ * Configuration options for error recovery mechanisms
+ */
+export interface ErrorRecoveryOptions {
+    autoRetry: boolean;
+    showUserFeedback: boolean;
+    logErrorsToAnalytics: boolean;
+    preserveQueueOnError: boolean;
+    fallbackToNextTrack: boolean;
+}
+/**
+ * Callback function type for audio error events
+ */
+export type AudioErrorCallback = (errorInfo: AudioErrorInfo) => void;
+/**
+ * Extended audio queue channel with error handling capabilities
+ */
+export interface ExtendedAudioQueueChannel {
+    audioCompleteCallbacks: Set<AudioCompleteCallback>;
+    audioErrorCallbacks: Set<AudioErrorCallback>;
+    audioPauseCallbacks: Set<AudioPauseCallback>;
+    audioResumeCallbacks: Set<AudioResumeCallback>;
+    audioStartCallbacks: Set<AudioStartCallback>;
+    fadeState?: ChannelFadeState;
     isPaused?: boolean;
-    /** Map of audio elements to their progress callback sets */
-    progressCallbacks?: Map<HTMLAudioElement, Set<ProgressCallback>>;
-    /** Set of callbacks for queue change events */
-    queueChangeCallbacks?: Set<QueueChangeCallback>;
-    /** Current volume level for this channel (0-1) */
+    progressCallbacks: Map<HTMLAudioElement | null, Set<ProgressCallback>>;
+    queue: HTMLAudioElement[];
+    queueChangeCallbacks: Set<QueueChangeCallback>;
+    retryConfig?: RetryConfig;
     volume?: number;
-    /** Volume ducking configuration for this channel */
     volumeConfig?: VolumeConfig;
-};
+}
+/**
+ * Easing function types for volume transitions
+ */
+export declare enum EasingType {
+    Linear = "linear",
+    EaseIn = "ease-in",
+    EaseOut = "ease-out",
+    EaseInOut = "ease-in-out"
+}
+/**
+ * Fade type for pause/resume operations with integrated volume transitions
+ */
+export declare enum FadeType {
+    Linear = "linear",
+    Gentle = "gentle",
+    Dramatic = "dramatic"
+}
+/**
+ * Configuration for fade transitions
+ */
+export interface FadeConfig {
+    /** Duration in milliseconds for the fade transition */
+    duration: number;
+    /** Easing curve to use when pausing (fading out) */
+    pauseCurve: EasingType;
+    /** Easing curve to use when resuming (fading in) */
+    resumeCurve: EasingType;
+}
+/**
+ * Internal fade state tracking for pause/resume with fade functionality
+ */
+export interface ChannelFadeState {
+    /** The original volume level before fading began */
+    originalVolume: number;
+    /** The type of fade being used */
+    fadeType: FadeType;
+    /** Whether the channel is currently paused due to fade */
+    isPaused: boolean;
+}

package/dist/types.js

@@ -3,3 +3,23 @@
  * @fileoverview Type definitions for the audio-channel-queue package
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FadeType = exports.EasingType = void 0;
+/**
+ * Easing function types for volume transitions
+ */
+var EasingType;
+(function (EasingType) {
+    EasingType["Linear"] = "linear";
+    EasingType["EaseIn"] = "ease-in";
+    EasingType["EaseOut"] = "ease-out";
+    EasingType["EaseInOut"] = "ease-in-out";
+})(EasingType || (exports.EasingType = EasingType = {}));
+/**
+ * Fade type for pause/resume operations with integrated volume transitions
+ */
+var FadeType;
+(function (FadeType) {
+    FadeType["Linear"] = "linear";
+    FadeType["Gentle"] = "gentle";
+    FadeType["Dramatic"] = "dramatic";
+})(FadeType || (exports.FadeType = FadeType = {}));

package/dist/volume.d.ts

@@ -1,7 +1,18 @@
 /**
  * @fileoverview Volume management functions for the audio-channel-queue package
  */
-import { VolumeConfig } from './types';
+import { VolumeConfig, FadeType, FadeConfig, EasingType } from './types';
+/**
+ * Gets the fade configuration for a specific fade type
+ * @param fadeType - The fade type to get configuration for
+ * @returns Fade configuration object
+ * @example
+ * ```typescript
+ * const config = getFadeConfig('gentle');
+ * console.log(`Gentle fade duration: ${config.duration}ms`);
+ * ```
+ */
+export declare const getFadeConfig: (fadeType: FadeType) => FadeConfig;
 /**
  * Smoothly transitions volume for a specific channel over time
  * @param channelNumber - The channel number to transition
@@ -14,7 +25,7 @@ import { VolumeConfig } from './types';
  * await transitionVolume(0, 0.2, 500, 'ease-out'); // Duck to 20% over 500ms
  * ```
  */
-export declare const transitionVolume: (channelNumber: number, targetVolume: number, duration?: number, easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out") => Promise<void>;
+export declare const transitionVolume: (channelNumber: number, targetVolume: number, duration?: number, easing?: EasingType) => Promise<void>;
 /**
  * Sets the volume for a specific channel with optional smooth transition
  * @param channelNumber - The channel number to set volume for
@@ -27,7 +38,7 @@ export declare const transitionVolume: (channelNumber: number, targetVolume: num
  * setChannelVolume(0, 0.5, 300, 'ease-out'); // Smooth transition over 300ms
  * ```
  */
-export declare const setChannelVolume: (channelNumber: number, volume: number, transitionDuration?: number, easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out") => Promise<void>;
+export declare const setChannelVolume: (channelNumber: number, volume: number, transitionDuration?: number, easing?: EasingType) => Promise<void>;
 /**
  * Gets the current volume for a specific channel
  * @param channelNumber - The channel number to get volume for (defaults to 0)
@@ -90,6 +101,20 @@ export declare const clearVolumeDucking: () => void;
  * @internal
  */
 export declare const applyVolumeDucking: (activeChannelNumber: number) => Promise<void>;
+/**
+ * Fades the volume for a specific channel over time (alias for transitionVolume with improved naming)
+ * @param channelNumber - The channel number to fade
+ * @param targetVolume - Target volume level (0-1)
+ * @param duration - Fade duration in milliseconds (defaults to 250)
+ * @param easing - Easing function type (defaults to 'ease-out')
+ * @returns Promise that resolves when fade completes
+ * @example
+ * ```typescript
+ * await fadeVolume(0, 0, 800, 'ease-in'); // Fade out over 800ms
+ * await fadeVolume(0, 1, 600, 'ease-out'); // Fade in over 600ms
+ * ```
+ */
+export declare const fadeVolume: (channelNumber: number, targetVolume: number, duration?: number, easing?: EasingType) => Promise<void>;
 /**
  * Restores normal volume levels when priority channel stops with smooth transitions
  * @param stoppedChannelNumber - The channel that just stopped playing