Référence du SDK

module.command(nom, gestionnaire)

Répond à une commande slash déclarée.

module.command('ping', async (ctx) => ctx.reply('pong'));

module.on(événement, gestionnaire)

Réagit à un événement du serveur.

module.on('memberJoin', async (ctx) => ctx.log(ctx.member.name + ' arrive'));

module.button(id, gestionnaire)

Réagit au clic sur un bouton envoyé par le module.

module.button('valider', async (ctx) => ctx.edit('Validé par ' + ctx.member.name));

module.select(id, gestionnaire)

Réagit à un choix dans un menu. Le choix est dans ctx.select.

module.form(id, gestionnaire)

Reçoit un formulaire envoyé. Les réponses sont dans ctx.form.values.

module.autocomplete(commande, gestionnaire)

Propose des choix pendant la saisie d’une option autocomplete.

RenvoieLes choix proposés.

module.userMenu(nom, gestionnaire)

Action du clic droit sur un membre. Le membre visé est dans ctx.target.

module.messageMenu(nom, gestionnaire)

Action du clic droit sur un message. Le message est dans ctx.target.

module.action(id, gestionnaire)

Bouton du dashboard déclaré dans Commandes et listes. ctx.reply s’affiche à l’admin.

module.row(id, gestionnaire)

Bouton d’une ligne de liste du dashboard. L’élément est dans ctx.item.

module.task(nom, gestionnaire)

Tâche lancée plus tard par ctx.later. Les données sont dans ctx.task.

module.every(id, quand, gestionnaire)

À intervalle régulier ou à heure fixe (heure de Paris).

module.every('bilan', { every: 'week', day: 0, at: '18:00' }, async (ctx) => {
  const top = await ctx.points('xp').top(5);
  await ctx.send(ctx.config.salon, { title: 'Top de la semaine', text: top.text });
});

module.uses(...éléments)

Déclare une permission ('roles.manage') ou un site ('api.exemple.com', '*.exemple.com') que l’éditeur ne peut pas deviner.

module.uses('roles.manage', 'api.exemple.com');

ctx.reply(contenu, { public }?)

Répond à la commande, au clic, au formulaire ou au clic droit. Visible par la personne seule sauf public: true. Depuis le dashboard, s’affiche à l’admin.

await ctx.reply({ title: 'Profil', text: ctx.member.mention, color: '#86a8cf' }, { public: true });

ctx.defer({ public }?)

Affiche « Opale réfléchit… ». À appeler avant un travail de plus de 3 secondes, puis editReply ou reply.

ctx.editReply(contenu)

Remplace la première réponse.

ctx.followUp(contenu, { public }?)

Ajoute un message après la première réponse.

RenvoieLe message (objet Discord).

ctx.deleteReply()

Supprime la première réponse.

ctx.edit(contenu)

Modifie le message du bouton ou du menu utilisé.

ctx.setButtonLabels({ id: texte })

Change le texte de boutons du message cliqué, par identifiant.

await ctx.setButtonLabels({ oui: 'Oui (12)', non: 'Non (4)' });

ctx.openForm({ id, title, fields })

Ouvre un formulaire (5 questions). Doit être la première réponse.

ctx.showModal({ custom_id, title, components })

Ouvre un formulaire au format Discord brut (champs texte, menus dans des composants « label »).

ctx.suggest(choix)

Dans module.autocomplete, propose jusqu’à 25 choix. Équivaut à les renvoyer.

ctx.send(salon, contenu)

Envoie un message dans un salon.

Renvoie{ id, channelId, url }

const msg = await ctx.send(ctx.config.salon, 'Nouvelle annonce !');
await ctx.pin(msg);

ctx.dm(membre, contenu)

Envoie un message privé.

Renvoietrue, ou false si ses messages privés sont fermés.

ctx.react(émoji)

Réagit au message de l’événement (messageCreate, reactionAdd, clic droit sur un message).

ctx.deleteMessage()

Supprime le message de l’événement.

ctx.pin(message)

Épingle un message envoyé par le module.

ctx.deleteLater(message, secondes?)

Supprime un message envoyé par le module après 5 à 3600 secondes (30 par défaut).

ctx.createThread(nom)

Ouvre un fil sur le message de l’événement.

Renvoie{ id, mention, name }

ctx.messages.get(salon, id)

Lit un message.

RenvoieLe message Discord, avec url.

ctx.messages.list(salon, { limit, before, after, around }?)

Les derniers messages (50 par défaut, 100 max).

ctx.messages.edit(message, contenu)

Modifie un message envoyé par Opale.

ctx.messages.delete(message, raison?)

Supprime un message.

ctx.messages.bulkDelete(salon, ids)

Supprime 2 à 100 messages de moins de 14 jours d’un coup.

ctx.messages.react(message, émoji)

Ajoute une réaction d’Opale.

ctx.messages.unreact(message, émoji, membre?)

Retire une réaction (d’Opale par défaut).

ctx.messages.clearReactions(message, émoji?)

Retire toutes les réactions, ou celles d’un émoji.

ctx.messages.reactions(message, émoji, { limit, after }?)

Les membres qui ont réagi avec cet émoji.

ctx.messages.pin(message)

Épingle n’importe quel message.

ctx.messages.unpin(message)

Désépingle.

ctx.messages.pins(salon)

Les messages épinglés.

ctx.messages.crosspost(message)

Publie un message d’un salon d’annonces vers les serveurs abonnés.

ctx.messages.endPoll(message)

Termine un sondage tout de suite.

ctx.messages.pollVoters(message, numéroDeRéponse, { limit, after }?)

Les membres qui ont voté pour une réponse.

ctx.createChannel({ name, category, private, allowRoles, allowMembers })

Crée un salon texte, éventuellement privé (le staff et les membres choisis).

Renvoie{ id, mention, name }

const salon = await ctx.createChannel({ name: 'ticket-' + ctx.member.name, private: true, allowMembers: [ctx.member], allowRoles: [ctx.config.staff] });

ctx.lockChannel(salon) / ctx.unlockChannel(salon)

Empêche ou ré-autorise @everyone à écrire.

ctx.channels.get(id) / ctx.channels.list()

Lit un salon, ou tous les salons du serveur.

ctx.channels.create(body, raison?)

Crée un salon de n’importe quel type : type 0 texte, 2 vocal, 4 catégorie, 5 annonces, 13 conférence, 15 forum.

await ctx.channels.create({ name: 'Événements', type: 4 });

ctx.channels.edit(id, body, raison?)

Modifie un salon : nom, sujet, mode lent (rate_limit_per_user), catégorie, position…

ctx.channels.delete(id, raison?)

Supprime un salon ou un fil.

ctx.channels.setPermissions(salon, cible, { allow, deny, type }, raison?)

Change les permissions d’un rôle ou d’un membre dans un salon. allow et deny sont des nombres de permissions Discord (en texte).

await ctx.channels.setPermissions(ctx.config.salon, ctx.member, { allow: '3072' });

ctx.channels.removePermissions(salon, cible, raison?)

Retire les permissions particulières d’un rôle ou d’un membre.

ctx.channels.createThread(salon, { name, message, private, invitable, archiveAfter, firstMessage })

Crée un fil (sur un message si message est donné), ou un post de forum avec firstMessage.

ctx.channels.addToThread(fil, membre) / removeFromThread(fil, membre)

Ajoute ou retire un membre d’un fil.

ctx.channels.typing(salon)

Affiche « Opale est en train d’écrire… » pendant 10 secondes.

ctx.channels.activeThreads()

Les fils actifs du serveur.

ctx.channels.setVoiceStatus(salon, texte)

Change le statut affiché d’un salon vocal.

ctx.members.get(membre)

Le membre au format Opale (id, mention, name, roles…), ou null s’il n’est plus là.

ctx.members.fetch(membre)

Le membre au format Discord brut.

ctx.members.list({ limit, after }?)

Tous les membres, 1000 par page.

ctx.members.search(texte, limite?)

Cherche par début de pseudo.

ctx.members.edit(membre, body, raison?)

Modifie nick, roles, mute, deaf, channel_id, communication_disabled_until. Chaque champ demande sa permission.

ctx.members.move(membre, salonVocal | null)

Déplace en vocal (ou déconnecte avec null).

ctx.members.disconnect(membre)

Déconnecte du vocal.

ctx.members.mute(membre, actif?) / deafen(membre, actif?)

Coupe ou rétablit le micro / le casque en vocal.

ctx.members.untimeout(membre)

Lève une exclusion temporaire.

ctx.members.unban(utilisateur, raison?)

Lève un bannissement.

ctx.members.bans({ limit, after }?)

La liste des bannis.

ctx.members.banMany(membres, secondesEffacées?, raison?)

Bannit jusqu’à 200 membres d’un coup. Le propriétaire et les admins bloquent tout l’appel.

Renvoie{ banned_users, failed_users }

ctx.members.voiceState(membre)

L’état vocal d’un membre (channel_id, self_mute…). Échoue s’il n’est pas en vocal.

ctx.members.prune(jours?, simulation?)

Compte (par défaut) ou expulse les membres inactifs depuis X jours.

ctx.addRole(rôle, membre?) / ctx.removeRole(rôle, membre?)

Donne ou retire un rôle (au membre courant par défaut).

ctx.timeout(membre, minutes?, raison?)

Rend muet de 1 minute à 7 jours (10 par défaut).

ctx.kick(membre, raison?)

Expulse.

ctx.ban(membre, raison?, { deleteSeconds }?)

Bannit. deleteSeconds efface ses messages récents (7 jours max).

ctx.setNickname(membre, pseudo)

Change le pseudo (texte vide pour le retirer).

ctx.roles.list() / ctx.roles.get(id)

Les rôles du serveur.

ctx.roles.create(body, raison?)

Crée un rôle : name, color (nombre), hoist, mentionable, permissions (sans permission dangereuse).

const r = await ctx.roles.create({ name: 'Gagnant', color: 0xc9a86a });
await ctx.addRole(r.id);

ctx.roles.edit(id, body, raison?)

Modifie un rôle (sous celui d’Opale).

ctx.roles.delete(id, raison?)

Supprime un rôle.

ctx.roles.move([{ id, position }])

Change l’ordre des rôles.

ctx.roles.counts()

Le nombre de membres par rôle : { idDuRôle: nombre }.

ctx.guild.fetch()

Le serveur au format Discord, avec le nombre de membres.

ctx.guild.edit(body, raison?)

Modifie le serveur : nom, icône, description, salon système…

ctx.guild.auditLog({ limit, action_type, user_id, before }?)

Le journal d’audit.

Renvoie{ audit_log_entries, users }

ctx.guild.invites()

Toutes les invitations du serveur, avec leurs utilisations.

ctx.guild.welcomeScreen(body?)

Lit, ou modifie si body est donné, l’écran de bienvenue.

ctx.guild.onboarding(body?)

Lit, ou modifie, le parcours d’accueil (questions de Discord).

ctx.guild.widget()

Le widget public (membres en ligne).

ctx.emojis.create({ name, image }, raison?)

Ajoute un émoji au serveur.

const img = await ctx.fetch('https://exemple.com/logo.png');
await ctx.emojis.create({ name: 'logo', image: 'data:image/png;base64,' + img.base64 });

ctx.events.create(body, raison?)

Programme un événement : name, scheduled_start_time (ISO), entity_type (2 vocal, 1 conférence, 3 externe), channel_id ou entity_metadata.location. Aussi : list(), get(id), users(id), edit(id, body), delete(id).

ctx.invites.create(salon, { max_age, max_uses, temporary, unique }?, raison?)

Crée une invitation (24 h par défaut ; max_age: 0 = permanente).

RenvoieL’invitation : code… Le lien est https://discord.gg/ + code.

ctx.invites.get(code) / delete(code, raison?) / list(salon?)

Lit, supprime ou liste des invitations.

ctx.webhooks.create(salon, { name, avatar }?, raison?)

Crée un webhook. Garde son id et son token dans ctx.storage pour le réutiliser. Aussi : list(salon?), edit(id, body), delete(id).

ctx.webhooks.send({ id, token }, contenu, { username, avatarUrl, thread, threadName }?)

Envoie avec un autre nom et un autre avatar.

await ctx.webhooks.send(hook, 'Bonjour !', { username: 'Le crieur', avatarUrl: ctx.member.avatar });

ctx.automod.create(body, raison?)

Crée une règle AutoMod (trigger_type, trigger_metadata, actions…). Aussi : list(), get(id), edit(id, body), delete(id).

ctx.discord.get(chemin, query?)

Appelle une route autorisée en GET.

RenvoieLa réponse de Discord.

ctx.discord.post(chemin, body?, { query, reason, files }?) — et put, patch

Appelle une route en POST, PUT ou PATCH.

ctx.discord.delete(chemin, { reason }?)

Appelle une route en DELETE.

ctx.discord.request(méthode, chemin, { body, query, reason, files }?)

Forme générale.

ctx.storage.get(clé) / set(clé, valeur) / increment(clé, pas?)

Valeurs propres au serveur. increment renvoie la nouvelle valeur.

ctx.memory.get(nom, membre?) / set(nom, valeur, membre?) / add(nom, pas?, membre?) / delete(nom, membre?)

Valeurs par membre (le membre courant par défaut), visibles dans le dashboard.

ctx.collection(nom).add(item) / get(id) / find(where) / list({ where, limit, offset }) / count(where) / update(id, set) / delete(id)

Listes d’éléments. list renvoie { items, total } (50 par défaut, 200 max).

ctx.points(classement?).add(membre, pas?) / get(membre?) / top(limite?)

Classements. get renvoie { points, rank }, top renvoie { rows, text }.

ctx.coins.add(membre, montant, raison?)

Pièces du module Économie (activé sur le serveur). Renvoie le nouveau solde.

ctx.later(tâche, minutes, données?)

Lance module.task(tâche) dans 1 minute à 7 jours.

Renvoie{ task, at }

ctx.sleep(ms)

Attend (5 secondes maximum).

ctx.fetch(url, { method, headers, json, body }?)

Appelle un site déclaré.

Renvoie{ ok, status, url, headers, body, json, base64, contentType, size }

ctx.voice.play(url, { channel, volume, title }?)

Joue un son. Aussi : join, pause, resume, stop, leave, status, soundboard. Voir Vocal.

Renvoie{ channelId, playing, title }

ctx.log(texte)

Écrit dans le journal du module (visible par l’admin).