Autocomplete Error!

D

d.js toolkit•7/2/23, 6:34 AM

• What's your exact discord.js

npm list discord.js

npm list discord.js

and node

node -v

node -v

version?
• Post the full error stack trace, not just the top part!
• Show your code!
• Explain what exactly your issue is.
• Not a discord.js issue? Check out #useful-servers.

D

d.js docsAPP•7/2/23, 6:35 AM

Slash Commands: Autocomplete
read more

B

Brahmendra•7/2/23, 6:36 AM

i did

B

Brahmendra•7/2/23, 6:36 AM

module.exports = class Akinator extends Command {
    constructor(client) {
        super(client, {
            data: new SlashCommandBuilder()
                .setName('akinator')
                .setDescription('Play Akinator Game.')
                .setDMPermission(true)
                .addStringOption(option =>
                    option.setName(`language`)
                        .setDescription(`In Which Language You Want To Play Akinator`)
                        .setRequired(true)
                        .setAutocomplete(true)),
            async autocomplete(interaction) {
                const focusedValue = interaction.options.getFocused();
                const choices = ['Popular Topics: Threads', 'Sharding: Getting started', 'Library: Voice Connections', 'Interactions: Replying to slash commands', 'Popular Topics: Embed preview'];
                const filtered = choices.filter(choice => choice.includes(focusedValue));
                await interaction.respond(
                    filtered.map(choice => ({ name: choice, value: choice })),
                );
            },
            usage: 'akinator',
            category: 'akinator',
            permissions: ['Use Application Commands', 'Send Messages', 'Embed Links'],
        });
    }
    async run(client, interaction) {

        
    }
};

module.exports = class Akinator extends Command {
    constructor(client) {
        super(client, {
            data: new SlashCommandBuilder()
                .setName('akinator')
                .setDescription('Play Akinator Game.')
                .setDMPermission(true)
                .addStringOption(option =>
                    option.setName(`language`)
                        .setDescription(`In Which Language You Want To Play Akinator`)
                        .setRequired(true)
                        .setAutocomplete(true)),
            async autocomplete(interaction) {
                const focusedValue = interaction.options.getFocused();
                const choices = ['Popular Topics: Threads', 'Sharding: Getting started', 'Library: Voice Connections', 'Interactions: Replying to slash commands', 'Popular Topics: Embed preview'];
                const filtered = choices.filter(choice => choice.includes(focusedValue));
                await interaction.respond(
                    filtered.map(choice => ({ name: choice, value: choice })),
                );
            },
            usage: 'akinator',
            category: 'akinator',
            permissions: ['Use Application Commands', 'Send Messages', 'Embed Links'],
        });
    }
    async run(client, interaction) {

        
    }
};

module.exports = class Akinator extends Command {
    constructor(client) {
        super(client, {
            data: new SlashCommandBuilder()
                .setName('akinator')
                .setDescription('Play Akinator Game.')
                .setDMPermission(true)
                .addStringOption(option =>
                    option.setName(`language`)
                        .setDescription(`In Which Language You Want To Play Akinator`)
                        .setRequired(true)
                        .setAutocomplete(true)),
            async autocomplete(interaction) {
                const focusedValue = interaction.options.getFocused();
                const choices = ['Popular Topics: Threads', 'Sharding: Getting started', 'Library: Voice Connections', 'Interactions: Replying to slash commands', 'Popular Topics: Embed preview'];
                const filtered = choices.filter(choice => choice.includes(focusedValue));
                await interaction.respond(
                    filtered.map(choice => ({ name: choice, value: choice })),
                );
            },
            usage: 'akinator',
            category: 'akinator',
            permissions: ['Use Application Commands', 'Send Messages', 'Embed Links'],
        });
    }
    async run(client, interaction) {

        
    }
};

module.exports = class Akinator extends Command {
    constructor(client) {
        super(client, {
            data: new SlashCommandBuilder()
                .setName('akinator')
                .setDescription('Play Akinator Game.')
                .setDMPermission(true)
                .addStringOption(option =>
                    option.setName(`language`)
                        .setDescription(`In Which Language You Want To Play Akinator`)
                        .setRequired(true)
                        .setAutocomplete(true)),
            async autocomplete(interaction) {
                const focusedValue = interaction.options.getFocused();
                const choices = ['Popular Topics: Threads', 'Sharding: Getting started', 'Library: Voice Connections', 'Interactions: Replying to slash commands', 'Popular Topics: Embed preview'];
                const filtered = choices.filter(choice => choice.includes(focusedValue));
                await interaction.respond(
                    filtered.map(choice => ({ name: choice, value: choice })),
                );
            },
            usage: 'akinator',
            category: 'akinator',
            permissions: ['Use Application Commands', 'Send Messages', 'Embed Links'],
        });
    }
    async run(client, interaction) {

        
    }
};

B

Brahmendra•7/2/23, 6:37 AM

now what should i do

B

Brahmendra•7/2/23, 6:38 AM

@qjuh

B

Brahmendra•7/2/23, 6:39 AM

Kk

B

Brahmendra•7/2/23, 6:40 AM

Like This???

module.exports = class Akinator extends Command {
    constructor(client) {
        super(client, {
            data: new SlashCommandBuilder()
                .setName('akinator')
                .setDescription('Play Akinator Game.')
                .setDMPermission(true)
                .addStringOption(option =>
                    option.setName(`language`)
                        .setDescription(`In Which Language You Want To Play Akinator`)
                        .setRequired(true)
                        .setAutocomplete(true)),
            usage: 'akinator',
            category: 'akinator',
            permissions: ['Use Application Commands', 'Send Messages', 'Embed Links'],
        });
    }

    async autocomplete(interaction) {
        const focusedValue = interaction.options.getFocused();
        const choices = ['Popular Topics: Threads', 'Sharding: Getting started', 'Library: Voice Connections', 'Interactions: Replying to slash commands', 'Popular Topics: Embed preview'];
        const filtered = choices.filter(choice => choice.includes(focusedValue));
        await interaction.respond(
            filtered.map(choice => ({ name: choice, value: choice })),
        );
    }

    async run(client, interaction) {
        // Your command logic goes here
    }
};

module.exports = class Akinator extends Command {
    constructor(client) {
        super(client, {
            data: new SlashCommandBuilder()
                .setName('akinator')
                .setDescription('Play Akinator Game.')
                .setDMPermission(true)
                .addStringOption(option =>
                    option.setName(`language`)
                        .setDescription(`In Which Language You Want To Play Akinator`)
                        .setRequired(true)
                        .setAutocomplete(true)),
            usage: 'akinator',
            category: 'akinator',
            permissions: ['Use Application Commands', 'Send Messages', 'Embed Links'],
        });
    }

    async autocomplete(interaction) {
        const focusedValue = interaction.options.getFocused();
        const choices = ['Popular Topics: Threads', 'Sharding: Getting started', 'Library: Voice Connections', 'Interactions: Replying to slash commands', 'Popular Topics: Embed preview'];
        const filtered = choices.filter(choice => choice.includes(focusedValue));
        await interaction.respond(
            filtered.map(choice => ({ name: choice, value: choice })),
        );
    }

    async run(client, interaction) {
        // Your command logic goes here
    }
};

module.exports = class Akinator extends Command {
    constructor(client) {
        super(client, {
            data: new SlashCommandBuilder()
                .setName('akinator')
                .setDescription('Play Akinator Game.')
                .setDMPermission(true)
                .addStringOption(option =>
                    option.setName(`language`)
                        .setDescription(`In Which Language You Want To Play Akinator`)
                        .setRequired(true)
                        .setAutocomplete(true)),
            usage: 'akinator',
            category: 'akinator',
            permissions: ['Use Application Commands', 'Send Messages', 'Embed Links'],
        });
    }

    async autocomplete(interaction) {
        const focusedValue = interaction.options.getFocused();
        const choices = ['Popular Topics: Threads', 'Sharding: Getting started', 'Library: Voice Connections', 'Interactions: Replying to slash commands', 'Popular Topics: Embed preview'];
        const filtered = choices.filter(choice => choice.includes(focusedValue));
        await interaction.respond(
            filtered.map(choice => ({ name: choice, value: choice })),
        );
    }

    async run(client, interaction) {
        // Your command logic goes here
    }
};

module.exports = class Akinator extends Command {
    constructor(client) {
        super(client, {
            data: new SlashCommandBuilder()
                .setName('akinator')
                .setDescription('Play Akinator Game.')
                .setDMPermission(true)
                .addStringOption(option =>
                    option.setName(`language`)
                        .setDescription(`In Which Language You Want To Play Akinator`)
                        .setRequired(true)
                        .setAutocomplete(true)),
            usage: 'akinator',
            category: 'akinator',
            permissions: ['Use Application Commands', 'Send Messages', 'Embed Links'],
        });
    }

    async autocomplete(interaction) {
        const focusedValue = interaction.options.getFocused();
        const choices = ['Popular Topics: Threads', 'Sharding: Getting started', 'Library: Voice Connections', 'Interactions: Replying to slash commands', 'Popular Topics: Embed preview'];
        const filtered = choices.filter(choice => choice.includes(focusedValue));
        await interaction.respond(
            filtered.map(choice => ({ name: choice, value: choice })),
        );
    }

    async run(client, interaction) {
        // Your command logic goes here
    }
};

B

Brahmendra•7/2/23, 6:41 AM

@qjuh

B

Brahmendra•7/2/23, 6:41 AM

kk

B

Brahmendra•7/2/23, 6:42 AM

not working above one

B

Brahmendra•7/2/23, 6:44 AM

Yup Same Error

B

Brahmendra•7/2/23, 6:48 AM

kk

B

Brahmendra•7/2/23, 6:50 AM

{
  name: 'akinator',
  description: 'Play Akinator Game.',
  options: [
    {
      choices: undefined,
      autocomplete: true,
      type: 3,
      name: 'language',
      name_localizations: undefined,
      description: 'In Which Language You Want To Play Akinator',
      description_localizations: undefined,
      required: true,
      max_length: undefined,
      min_length: undefined
    }
  ],
  defaultPermission: undefined,
  contextDescription: null,
  usage: 'akinator',
  category: 'akinator',
  permissions: [ 'Use Application Commands', 'Send Messages', 'Embed Links' ],
  run: [AsyncFunction: run]
}

{
  name: 'akinator',
  description: 'Play Akinator Game.',
  options: [
    {
      choices: undefined,
      autocomplete: true,
      type: 3,
      name: 'language',
      name_localizations: undefined,
      description: 'In Which Language You Want To Play Akinator',
      description_localizations: undefined,
      required: true,
      max_length: undefined,
      min_length: undefined
    }
  ],
  defaultPermission: undefined,
  contextDescription: null,
  usage: 'akinator',
  category: 'akinator',
  permissions: [ 'Use Application Commands', 'Send Messages', 'Embed Links' ],
  run: [AsyncFunction: run]
}

{
  name: 'akinator',
  description: 'Play Akinator Game.',
  options: [
    {
      choices: undefined,
      autocomplete: true,
      type: 3,
      name: 'language',
      name_localizations: undefined,
      description: 'In Which Language You Want To Play Akinator',
      description_localizations: undefined,
      required: true,
      max_length: undefined,
      min_length: undefined
    }
  ],
  defaultPermission: undefined,
  contextDescription: null,
  usage: 'akinator',
  category: 'akinator',
  permissions: [ 'Use Application Commands', 'Send Messages', 'Embed Links' ],
  run: [AsyncFunction: run]
}

{
  name: 'akinator',
  description: 'Play Akinator Game.',
  options: [
    {
      choices: undefined,
      autocomplete: true,
      type: 3,
      name: 'language',
      name_localizations: undefined,
      description: 'In Which Language You Want To Play Akinator',
      description_localizations: undefined,
      required: true,
      max_length: undefined,
      min_length: undefined
    }
  ],
  defaultPermission: undefined,
  contextDescription: null,
  usage: 'akinator',
  category: 'akinator',
  permissions: [ 'Use Application Commands', 'Send Messages', 'Embed Links' ],
  run: [AsyncFunction: run]
}

B

Brahmendra•7/2/23, 6:55 AM

yes

B

Brahmendra•7/2/23, 6:56 AM

module.exports = class Command {
    constructor(client, meta = {}) {
        this.client = client;
        this.data = meta.data;
        this.contextDescription = meta.contextDescription || null;
        this.usage = meta.usage || this.name;
        this.category = meta.category || 'Info';
        this.permissions = meta.permissions || ['Use Application Commands', 'Send Messages', 'Embed Links'];
    }
    async run() {

        throw new Error(`The Slash Command "${this.name}" does not provide a run method.`);

    }
};

module.exports = class Command {
    constructor(client, meta = {}) {
        this.client = client;
        this.data = meta.data;
        this.contextDescription = meta.contextDescription || null;
        this.usage = meta.usage || this.name;
        this.category = meta.category || 'Info';
        this.permissions = meta.permissions || ['Use Application Commands', 'Send Messages', 'Embed Links'];
    }
    async run() {

        throw new Error(`The Slash Command "${this.name}" does not provide a run method.`);

    }
};

module.exports = class Command {
    constructor(client, meta = {}) {
        this.client = client;
        this.data = meta.data;
        this.contextDescription = meta.contextDescription || null;
        this.usage = meta.usage || this.name;
        this.category = meta.category || 'Info';
        this.permissions = meta.permissions || ['Use Application Commands', 'Send Messages', 'Embed Links'];
    }
    async run() {

        throw new Error(`The Slash Command "${this.name}" does not provide a run method.`);

    }
};

module.exports = class Command {
    constructor(client, meta = {}) {
        this.client = client;
        this.data = meta.data;
        this.contextDescription = meta.contextDescription || null;
        this.usage = meta.usage || this.name;
        this.category = meta.category || 'Info';
        this.permissions = meta.permissions || ['Use Application Commands', 'Send Messages', 'Embed Links'];
    }
    async run() {

        throw new Error(`The Slash Command "${this.name}" does not provide a run method.`);

    }
};

B

Brahmendra•7/2/23, 6:56 AM

Command Class

B

Brahmendra•7/2/23, 7:00 AM

can you help me now

B

Brahmendra•7/2/23, 7:00 AM

@qjuh

Similar Threads

Similar Threads

Similar Threads