Class : Manager

Constructor

Manager : options

new Magmastream.Manager(options: ManagerOptions)

Parameter	Type	Description
usePriority	boolean	Use priority mode over least amount of player or load?
useNode	UseNode	Use the least amount of players or least load?
nodes	Node[]	The array of nodes to connect to.
clientId	string as ClientUser.id	The client ID to use.
clientName	string	Value to use for the Client-Name header.
plugins	Plugin[]	A array of plugins to use.
autoPlay	boolean	Whether players should automatically play the next song.
autoPlaySearchPlatform	SearchPlatform	The search platform autoplay should use. Failback to Youtube if not found.
trackPartial	string[]	An array of track properties to keep. track will always be present.
defaultSearchPlatform	SearchPlatform	The default search platform to use.
replaceYouTubeCredentials	boolean	Whether the YouTube video titles should be replaced if the Author does not exactly match.
lastFmApiKey	string as apiKey	The last.fm API key. If you need to create one go here or if you already have one, get it from here.
send	function as send()	Function to send data to the websocket.

---

send(id, payload)

Parameters

Function to send data to the websocket.

Parameter	Type	Description
id	string	The ID of the node to send the data to.
payload	Payload	The payload to send

Usage

new Magmastream.Manager({
    ...ManagerOptions,
    send: (id, payload) => {
        const guild = client.guilds.cache.get(id);
        // NOTE: FOR ERIS YOU NEED JSON.stringify() THE PAYLOAD
        if (guild) guild.shard.send(payload);
    },
})

Table of contents

Properties	Methods	Events
initiated	create()	chapterStarted
nodes	createNode()	chaptersLoaded
options	decodeTrack()	debug
players	decodeTracks()	nodeConnect
	destroy()	nodeCreate
	destroyNode()	nodeDestroy
	get()	nodeDisconnect
	init()	nodeError
	loadPlayerStates()	nodeRaw
	on()	nodeReconnect
	savePlayerState()	playerCreate
	search()	playerDestroy
	updateVoiceState()	playerDisconnect
	useableNodes()	playerMove
		playerStateUpdate
		queueEnd
		segmentSkipped
		segmentsLoaded
		socketClosed
		trackEnd
		trackError
		trackStart
		trackStuck

Properties

initiated

Has the manager been initiated?

Return: boolean

---

players

readonly

The map of players.

Return: Collection<string, Player>

---

nodes

readonly

The map of nodes.

Return: Collection<string, Node>

---

options

readonly

The options that were set.

Return: managerOptions{}

Methods

create(options)

Creates a player or returns one if it already exists.

Return: Player

Parameter	Type	Description	Optional
options	playerOptions{}	The options to create the player with.

---

createNode(options)

Creates a new node or returns an existing one if it already exists.

Return: Node

Parameter	Type	Description	Optional
options	nodeOptions{}	The options to create the node with.

---

decodeTrack(track)

Decodes a base64 encoded track and returns a TrackData.

Return: Promise<trackData{}>

Parameter	Type	Description	Optional
track	string as base64	The base64 encoded track string.

---

decodeTracks(tracks)

Decodes an array of base64 encoded tracks and returns an array of TrackData.
Emits a debug event with the tracks being decoded.

Return: Promise<trackData{}[]>

Parameter	Type	Description	Optional
tracks	string[] as base64	The base64 encoded track string.

---

destroy(guildId)

Destroys a player if it exists and cleans up inactive players.

Return: void

Parameter	Type	Description	Optional
guildId	string as Guild.id	The guild ID of the player to destroy.

---

destroyNode(identifier)

Destroys a node if it exists. Emits a debug event if the node is found and destroyed.

Return: void

Parameter	Type	Description	Optional
identifier	string as Node.identifier	The identifier of the node to destroy.

---

init(clientId)

Initiates the Manager.

Return: this

Parameter	Type	Description	Optional
clientId	string as ClientUser.id	The Discord client ID (required).

---

loadPlayerStates(nodeId)

Loads player states from the JSON file.

Return: void

Parameter	Type	Description	Optional
nodeId	string as Node.identifier	The ID of the node to load player states from (required).

---

get(guildId)

Returns a player or undefined if it does not exist.

Return: Player | undefined

Parameter	Type	Description	Optional
guildId	string as Guild.id	The guild ID of the player to retrieve.

---

on(event, listener: () => {})

Attaches an event listener to the manager.

Return: this

Parameter	Type	Description	Optional
event	ManagerEventType	The event to listen for.
listener	function	The function to call when the event is emitted.

Example usage

const { Manager } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on('trackStart', (player, track) => {
    console.log(`Now playing ${track.title} in ${player.guildId}`);
});

---

savePlayerState(guildId)

Saves player states to the JSON file.

Return: void

Parameter	Type	Description	Optional
guildId	string as GuildId	The guild ID of the player to save

---

search(query, requester)

Searches the enabled sources based off the URL or the source property.

Return: Promise<searchResult{}>

Parameter	Type	Description	Optional
query	string | searchQuery{}	Query to search.
requester	User | ClientUser	The user who requested the track.

---

updateVoiceState(data)

Sends voice data to the Lavalink server.

Return: Promise<void>

Parameter	Type	Description	Optional
data	VoicePacket | VoiceServer | VoiceState	The timescale options to apply.

Example required to use

const { Client, Events } = require('discord.js');
const { Manager } = require('magmastream');

const client = new Client({
    ...ClientOptions
})

const manager = new Manager({
    ...ManagerOptions
})

// Required for magmastream to work
client.on(Events.Raw, (data) => {
    manager.updateVoiceState(data);
})

---

useableNodes()

get

Returns the node to use based on the configured useNode and usePriority options.

If usePriority is true, the node is chosen based on priority, otherwise it is chosen based on the useNode option.
If useNode is "leastLoad", the node with the lowest load is chosen, if it is "leastPlayers", the node with the fewest players is chosen.
If usePriority is false and useNode is not set, the node with the lowest load is chosen.

Return: Node

Events

ChapterStarted

ManagerEventTypes : ChapterStarted

Emitted when a track has started a chapter.

Parameter	Type
player	Player
track	track{} | unresolvedTrack{}
payload	SponsorBlockChapterStarted{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.ChapterStarted, (player, track, payload) => {
    //Your code
})

---

ChaptersLoaded

ManagerEventTypes : ChaptersLoaded

Emitted when a track has loaded chapters.

Parameter	Type
player	Player
track	track{} | unresolvedTrack{}
payload	SponsorBlockChaptersLoaded{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.ChapterStarted, (player, track, payload) => {
//Your code
})

---

Debug

ManagerEventTypes : Debug

Emitted when a track has loaded chapters.

Parameter	Type
info	string

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
...ManagerOptions
})

manager.on(ManagerEventTypes.Debug, (info) => {
    console.log(`Debug from magmastream: ${info}`);
    //Your code
})

---

NodeConnect

ManagerEventTypes : NodeConnect

Emitted when a Node connects.

Parameter	Type
node	Node

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.NodeConnect, (player, track, payload) => {
    //Your code
})

---

NodeCreate

ManagerEventTypes : NodeCreate

Emitted when a Node is created.

Parameter	Type
node	Node

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.NodeCreate, (player, track, payload) => {
    //Your code
})

---

NodeDestroy

ManagerEventTypes : NodeDestroy

Emitted when a Node is destroyed.

Parameter	Type
node	Node

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.NodeDestroy, (player, track, payload) => {
    //Your code
})

---

NodeDisconnect

ManagerEventTypes : NodeDisconnect

Emitted when a Node is disconnects.

Parameter	Type
node	Node
reason	{ code: number, reason: string }

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.NodeDisconnect, (player, track, payload) => {
    //Your code
})

---

NodeError

ManagerEventTypes : NodeError

Emitted when a Node has an error.

Parameter	Type
node	Node
error	Error

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.NodeError, (player, track, payload) => {
    //Your code
})

---

NodeRaw

ManagerEventTypes : NodeRaw

Emitted whenever any Lavalink event is received.

Parameter	Type
payload	unknown

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.NodeRaw, (player, track, payload) => {
    //Your code
})

---

NodeReconnect

ManagerEventTypes : NodeReconnect

Emitted when a Node reconnects.

Parameter	Type
node	Node

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.NodeReconnect, (player, track, payload) => {
    //Your code
})

---

PlayerCreate

ManagerEventTypes : PlayerCreate

Emitted when a player is created.

Parameter	Type
player	Player

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.PlayerCreate, (player) => {
    //Your code
})

---

PlayerDestroy

ManagerEventTypes : PlayerDestroy

Emitted when a player is destroyed.

Parameter	Type
player	Player

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.PlayerDestroy, (player) => {
    //Your code
})

---

PlayerDisconnect

ManagerEventTypes : PlayerDisconnect

Emitted when a Player disconnects.

Parameter	Type
player	Player
oldChannel	string as GuildChannelId

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.PlayerDisconnect, (player, oldChannel) => {
    //Your code
})

---

PlayerMove

ManagerEventTypes : PlayerMove

Emitted when a player is moved to a new voice channel.

Parameter	Type
player	Player
initChannel	string as GuildChannelId
newChannel	string as GuildChannelId

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.NodeDisconnect, (player, initChannel, newChannel) => {
    //Your code
})

---

PlayerStateUpdate

ManagerEventTypes : PlayerStateUpdate

Emitted when the state of the player has been changed either player paused/resumed or the loop modes have been toggled on or off.

Parameter	Type
oldPlayer	Player
newPlayer	Player
changeType	playerStateUpdateEvent{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.PlayerStateUpdate, (oldPlayer, newPlayer, changeType) => {
    //Your code
})

---

QueueEnd

ManagerEventTypes : QueueEnd

Emitted when a player queue ends.

Parameter	Type
player	Player
track	track{} | unresolvedTrack{}
payload	TrackEndEvent{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.QueueEnd, (player, track, payload) => {
    //Your code
})

---

SegmentSkipped

ManagerEventTypes : SegmentSkipped

Emitted when a track has skipped a segment.

Parameter	Type
player	Player
track	track{} | unresolvedTrack{}
payload	SponsorBlockSegmentSkipped{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.SegmentSkipped, (player, track, payload) => {
    //Your code
})

---

SegmentsLoaded

ManagerEventTypes : SegmentsLoaded

Emitted when a track has loaded segments.

Parameter	Type
player	Player
track	track{} | unresolvedTrack{}
payload	SponsorBlockSegmentsLoaded{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.SegmentsLoaded, (player, track, payload) => {
    //Your code
})

---

SocketClosed

ManagerEventTypes : SocketClosed

Emitted when a voice connection is closed.

Parameter	Type
player	Player
payload	WebSocketClosedEvent{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.SocketClosed, (player, track, payload) => {
    //Your code
})

---

TrackEnd

ManagerEventTypes : TrackEnd

Emitted when a track ends.

Parameter	Type
player	Player
track	track{}
payload	TrackEndEvent{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.TrackEnd, (player, track, payload) => {
    //Your code
})

---

TrackError

ManagerEventTypes : TrackError

Emitted when a track has an error during playback.

Parameter	Type
player	Player
track	track{} | unresolvedTrack{}
payload	TrackExceptionEvent{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.TrackError, (player, track, payload) => {
    //Your code
})

---

TrackStart

ManagerEventTypes : TrackStart

Emitted when a track starts.

Parameter	Type
player	Player
track	track{}
payload	TrackStartEvent{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.TrackStart, (player, track, payload) => {
    //Your code
})

---

TrackStuck

ManagerEventTypes : TrackStuck

Emitted when a track gets stuck during playback.

Parameter	Type
player	Player
track	track{}
payload	TrackStuckEvent{}

Example usage

const { Manager, ManagerEventTypes } = require('magmastream');

const manager = new Manager({
    ...ManagerOptions
})

manager.on(ManagerEventTypes.TrackStuck, (player, track, payload) => {
    //Your code
})