Class PlayerAPI

client

• get client(): LavalinkHttpClient

• Returns LavalinkHttpClient

constructor

• new PlayerAPI(session, id): PlayerAPI

• Parameters

  • session: SessionAPI

  • id: string

  Returns PlayerAPI

delete

• delete(): Promise<void>

• Returns Promise<void>

fetch

• fetch(): Promise<{
      filters: {
          channelMix?: {
              leftToLeft?: number;
              leftToRight?: number;
              rightToLeft?: number;
              rightToRight?: number;
          };
          distortion?: {
              cosOffset?: number;
              cosScale?: number;
              offset?: number;
              scale?: number;
              sinOffset?: number;
              sinScale?: number;
              tanOffset?: number;
              tanScale?: number;
          };
          equalizer?: readonly {
              band: number;
              gain?: number;
          }[];
          karaoke?: {
              filterBand?: number;
              filterWidth?: number;
              level?: number;
              monoLevel?: number;
          };
          lowPass?: {
              smoothing?: number;
          };
          pluginFilters?: {
              [x: string]: unknown;
          };
          rotation?: {
              rotationHz?: number;
          };
          timescale?: {
              pitch?: number;
              rate?: number;
              speed?: number;
          };
          tremolo?: {
              depth?: number;
              frequency?: number;
          };
          vibrato?: {
              depth?: number;
              frequency?: number;
          };
          volume?: number;
      };
      guildId: string;
      paused: boolean;
      state: {
          connected: boolean;
          ping: number;
          position: number;
          time: number;
      };
      track: {
          encoded: string;
          info: {
              artworkUrl: string;
              author: string;
              identifier: string;
              isSeekable: boolean;
              isStream: boolean;
              isrc: string;
              length: number;
              position: number;
              sourceName: string;
              title: string;
              uri: string;
          };
          pluginInfo: {
              [x: string]: unknown;
          };
          userData: {
              [x: string]: unknown;
          };
      };
      voice: {
          endpoint: string;
          sessionId: string;
          token: string;
      };
      volume: number;
  }>

• Returns Promise<{
      filters: {
          channelMix?: {
              leftToLeft?: number;
              leftToRight?: number;
              rightToLeft?: number;
              rightToRight?: number;
          };
          distortion?: {
              cosOffset?: number;
              cosScale?: number;
              offset?: number;
              scale?: number;
              sinOffset?: number;
              sinScale?: number;
              tanOffset?: number;
              tanScale?: number;
          };
          equalizer?: readonly {
              band: number;
              gain?: number;
          }[];
          karaoke?: {
              filterBand?: number;
              filterWidth?: number;
              level?: number;
              monoLevel?: number;
          };
          lowPass?: {
              smoothing?: number;
          };
          pluginFilters?: {
              [x: string]: unknown;
          };
          rotation?: {
              rotationHz?: number;
          };
          timescale?: {
              pitch?: number;
              rate?: number;
              speed?: number;
          };
          tremolo?: {
              depth?: number;
              frequency?: number;
          };
          vibrato?: {
              depth?: number;
              frequency?: number;
          };
          volume?: number;
      };
      guildId: string;
      paused: boolean;
      state: {
          connected: boolean;
          ping: number;
          position: number;
          time: number;
      };
      track: {
          encoded: string;
          info: {
              artworkUrl: string;
              author: string;
              identifier: string;
              isSeekable: boolean;
              isStream: boolean;
              isrc: string;
              length: number;
              position: number;
              sourceName: string;
              title: string;
              uri: string;
          };
          pluginInfo: {
              [x: string]: unknown;
          };
          userData: {
              [x: string]: unknown;
          };
      };
      voice: {
          endpoint: string;
          sessionId: string;
          token: string;
      };
      volume: number;
  }>

fetchOrNull

• fetchOrNull(): Promise<{
      filters: {
          channelMix?: {
              leftToLeft?: number;
              leftToRight?: number;
              rightToLeft?: number;
              rightToRight?: number;
          };
          distortion?: {
              cosOffset?: number;
              cosScale?: number;
              offset?: number;
              scale?: number;
              sinOffset?: number;
              sinScale?: number;
              tanOffset?: number;
              tanScale?: number;
          };
          equalizer?: readonly {
              band: number;
              gain?: number;
          }[];
          karaoke?: {
              filterBand?: number;
              filterWidth?: number;
              level?: number;
              monoLevel?: number;
          };
          lowPass?: {
              smoothing?: number;
          };
          pluginFilters?: {
              [x: string]: unknown;
          };
          rotation?: {
              rotationHz?: number;
          };
          timescale?: {
              pitch?: number;
              rate?: number;
              speed?: number;
          };
          tremolo?: {
              depth?: number;
              frequency?: number;
          };
          vibrato?: {
              depth?: number;
              frequency?: number;
          };
          volume?: number;
      };
      guildId: string;
      paused: boolean;
      state: {
          connected: boolean;
          ping: number;
          position: number;
          time: number;
      };
      track: {
          encoded: string;
          info: {
              artworkUrl: string;
              author: string;
              identifier: string;
              isSeekable: boolean;
              isStream: boolean;
              isrc: string;
              length: number;
              position: number;
              sourceName: string;
              title: string;
              uri: string;
          };
          pluginInfo: {
              [x: string]: unknown;
          };
          userData: {
              [x: string]: unknown;
          };
      };
      voice: {
          endpoint: string;
          sessionId: string;
          token: string;
      };
      volume: number;
  }>

• Returns Promise<{
      filters: {
          channelMix?: {
              leftToLeft?: number;
              leftToRight?: number;
              rightToLeft?: number;
              rightToRight?: number;
          };
          distortion?: {
              cosOffset?: number;
              cosScale?: number;
              offset?: number;
              scale?: number;
              sinOffset?: number;
              sinScale?: number;
              tanOffset?: number;
              tanScale?: number;
          };
          equalizer?: readonly {
              band: number;
              gain?: number;
          }[];
          karaoke?: {
              filterBand?: number;
              filterWidth?: number;
              level?: number;
              monoLevel?: number;
          };
          lowPass?: {
              smoothing?: number;
          };
          pluginFilters?: {
              [x: string]: unknown;
          };
          rotation?: {
              rotationHz?: number;
          };
          timescale?: {
              pitch?: number;
              rate?: number;
              speed?: number;
          };
          tremolo?: {
              depth?: number;
              frequency?: number;
          };
          vibrato?: {
              depth?: number;
              frequency?: number;
          };
          volume?: number;
      };
      guildId: string;
      paused: boolean;
      state: {
          connected: boolean;
          ping: number;
          position: number;
          time: number;
      };
      track: {
          encoded: string;
          info: {
              artworkUrl: string;
              author: string;
              identifier: string;
              isSeekable: boolean;
              isStream: boolean;
              isrc: string;
              length: number;
              position: number;
              sourceName: string;
              title: string;
              uri: string;
          };
          pluginInfo: {
              [x: string]: unknown;
          };
          userData: {
              [x: string]: unknown;
          };
      };
      voice: {
          endpoint: string;
          sessionId: string;
          token: string;
      };
      volume: number;
  }>

remove

• remove(): Promise<boolean>

• Returns Promise<boolean>

update

• update(body, noReplace?): Promise<{
      filters: {
          channelMix?: {
              leftToLeft?: number;
              leftToRight?: number;
              rightToLeft?: number;
              rightToRight?: number;
          };
          distortion?: {
              cosOffset?: number;
              cosScale?: number;
              offset?: number;
              scale?: number;
              sinOffset?: number;
              sinScale?: number;
              tanOffset?: number;
              tanScale?: number;
          };
          equalizer?: readonly {
              band: number;
              gain?: number;
          }[];
          karaoke?: {
              filterBand?: number;
              filterWidth?: number;
              level?: number;
              monoLevel?: number;
          };
          lowPass?: {
              smoothing?: number;
          };
          pluginFilters?: {
              [x: string]: unknown;
          };
          rotation?: {
              rotationHz?: number;
          };
          timescale?: {
              pitch?: number;
              rate?: number;
              speed?: number;
          };
          tremolo?: {
              depth?: number;
              frequency?: number;
          };
          vibrato?: {
              depth?: number;
              frequency?: number;
          };
          volume?: number;
      };
      guildId: string;
      paused: boolean;
      state: {
          connected: boolean;
          ping: number;
          position: number;
          time: number;
      };
      track: {
          encoded: string;
          info: {
              artworkUrl: string;
              author: string;
              identifier: string;
              isSeekable: boolean;
              isStream: boolean;
              isrc: string;
              length: number;
              position: number;
              sourceName: string;
              title: string;
              uri: string;
          };
          pluginInfo: {
              [x: string]: unknown;
          };
          userData: {
              [x: string]: unknown;
          };
      };
      voice: {
          endpoint: string;
          sessionId: string;
          token: string;
      };
      volume: number;
  }>

• Parameters

  • body: {
        endTime?: number;
        filters?: {
            channelMix?: {
                leftToLeft?: number;
                leftToRight?: number;
                rightToLeft?: number;
                rightToRight?: number;
            };
            distortion?: {
                cosOffset?: number;
                cosScale?: number;
                offset?: number;
                scale?: number;
                sinOffset?: number;
                sinScale?: number;
                tanOffset?: number;
                tanScale?: number;
            };
            equalizer?: readonly {
                band: number;
                gain?: number;
            }[];
            karaoke?: {
                filterBand?: number;
                filterWidth?: number;
                level?: number;
                monoLevel?: number;
            };
            lowPass?: {
                smoothing?: number;
            };
            pluginFilters?: {
                [x: string]: unknown;
            };
            rotation?: {
                rotationHz?: number;
            };
            timescale?: {
                pitch?: number;
                rate?: number;
                speed?: number;
            };
            tremolo?: {
                depth?: number;
                frequency?: number;
            };
            vibrato?: {
                depth?: number;
                frequency?: number;
            };
            volume?: number;
        };
        paused?: boolean;
        position?: number;
        track?: {
            encoded: string;
            identifier?: string;
            userData?: {
                [x: string]: unknown;
            };
        };
        voice?: {
            endpoint: string;
            sessionId: string;
            token: string;
        };
        volume?: number;
    }

    • Optional Readonly endTime?: number

    • Optional Readonly filters?: {
          channelMix?: {
              leftToLeft?: number;
              leftToRight?: number;
              rightToLeft?: number;
              rightToRight?: number;
          };
          distortion?: {
              cosOffset?: number;
              cosScale?: number;
              offset?: number;
              scale?: number;
              sinOffset?: number;
              sinScale?: number;
              tanOffset?: number;
              tanScale?: number;
          };
          equalizer?: readonly {
              band: number;
              gain?: number;
          }[];
          karaoke?: {
              filterBand?: number;
              filterWidth?: number;
              level?: number;
              monoLevel?: number;
          };
          lowPass?: {
              smoothing?: number;
          };
          pluginFilters?: {
              [x: string]: unknown;
          };
          rotation?: {
              rotationHz?: number;
          };
          timescale?: {
              pitch?: number;
              rate?: number;
              speed?: number;
          };
          tremolo?: {
              depth?: number;
              frequency?: number;
          };
          vibrato?: {
              depth?: number;
              frequency?: number;
          };
          volume?: number;
      }

      • Optional Readonly channelMix?: {
            leftToLeft?: number;
            leftToRight?: number;
            rightToLeft?: number;
            rightToRight?: number;
        }

        • Optional Readonly leftToLeft?: number

        • Optional Readonly leftToRight?: number

        • Optional Readonly rightToLeft?: number

        • Optional Readonly rightToRight?: number

      • Optional Readonly distortion?: {
            cosOffset?: number;
            cosScale?: number;
            offset?: number;
            scale?: number;
            sinOffset?: number;
            sinScale?: number;
            tanOffset?: number;
            tanScale?: number;
        }

        • Optional Readonly cosOffset?: number

        • Optional Readonly cosScale?: number

        • Optional Readonly offset?: number

        • Optional Readonly scale?: number

        • Optional Readonly sinOffset?: number

        • Optional Readonly sinScale?: number

        • Optional Readonly tanOffset?: number

        • Optional Readonly tanScale?: number

      • Optional Readonly equalizer?: readonly {
            band: number;
            gain?: number;
        }[]

      • Optional Readonly karaoke?: {
            filterBand?: number;
            filterWidth?: number;
            level?: number;
            monoLevel?: number;
        }

        • Optional Readonly filterBand?: number

        • Optional Readonly filterWidth?: number

        • Optional Readonly level?: number

        • Optional Readonly monoLevel?: number

      • Optional Readonly lowPass?: {
            smoothing?: number;
        }

        • Optional Readonly smoothing?: number

      • Optional Readonly pluginFilters?: {
            [x: string]: unknown;
        }

        • [x: string]: unknown

      • Optional Readonly rotation?: {
            rotationHz?: number;
        }

        • Optional Readonly rotationHz?: number

      • Optional Readonly timescale?: {
            pitch?: number;
            rate?: number;
            speed?: number;
        }

        • Optional Readonly pitch?: number

        • Optional Readonly rate?: number

        • Optional Readonly speed?: number

      • Optional Readonly tremolo?: {
            depth?: number;
            frequency?: number;
        }

        • Optional Readonly depth?: number

        • Optional Readonly frequency?: number

      • Optional Readonly vibrato?: {
            depth?: number;
            frequency?: number;
        }

        • Optional Readonly depth?: number

        • Optional Readonly frequency?: number

      • Optional Readonly volume?: number

    • Optional Readonly paused?: boolean

    • Optional Readonly position?: number

    • Optional Readonly track?: {
          encoded: string;
          identifier?: string;
          userData?: {
              [x: string]: unknown;
          };
      }

      • Readonly encoded: string

      • Optional Readonly identifier?: string

      • Optional Readonly userData?: {
            [x: string]: unknown;
        }

        • [x: string]: unknown

    • Optional Readonly voice?: {
          endpoint: string;
          sessionId: string;
          token: string;
      }

      • Readonly endpoint: string

      • Readonly sessionId: string

      • Readonly token: string

    • Optional Readonly volume?: number

  • Optional noReplace: boolean

  Returns Promise<{
      filters: {
          channelMix?: {
              leftToLeft?: number;
              leftToRight?: number;
              rightToLeft?: number;
              rightToRight?: number;
          };
          distortion?: {
              cosOffset?: number;
              cosScale?: number;
              offset?: number;
              scale?: number;
              sinOffset?: number;
              sinScale?: number;
              tanOffset?: number;
              tanScale?: number;
          };
          equalizer?: readonly {
              band: number;
              gain?: number;
          }[];
          karaoke?: {
              filterBand?: number;
              filterWidth?: number;
              level?: number;
              monoLevel?: number;
          };
          lowPass?: {
              smoothing?: number;
          };
          pluginFilters?: {
              [x: string]: unknown;
          };
          rotation?: {
              rotationHz?: number;
          };
          timescale?: {
              pitch?: number;
              rate?: number;
              speed?: number;
          };
          tremolo?: {
              depth?: number;
              frequency?: number;
          };
          vibrato?: {
              depth?: number;
              frequency?: number;
          };
          volume?: number;
      };
      guildId: string;
      paused: boolean;
      state: {
          connected: boolean;
          ping: number;
          position: number;
          time: number;
      };
      track: {
          encoded: string;
          info: {
              artworkUrl: string;
              author: string;
              identifier: string;
              isSeekable: boolean;
              isStream: boolean;
              isrc: string;
              length: number;
              position: number;
              sourceName: string;
              title: string;
              uri: string;
          };
          pluginInfo: {
              [x: string]: unknown;
          };
          userData: {
              [x: string]: unknown;
          };
      };
      voice: {
          endpoint: string;
          sessionId: string;
          token: string;
      };
      volume: number;
  }>

Readonly id

Readonly session