Saltearse al contenido

Creando Encuestas

En Seyfert, la capacidad de crear encuestas está a la vuelta de la esquina!
Esta sección mostrará la creación básica de encuestas, eventos y ejemplos.

Gateway Intents

Esta es una sección ampliada del archivo de configuración.

export default config.bot({
   //... otras opciones
   intents: ['GuildMessagePolls', 'DirectMessagePolls'],
});

Recepción de eventos

Actualmente hay 2 eventos para las encuestas: messagePollVoteAdd y messagePollVoteRemove.

events/addVote.ts
events/removeVote.ts

import { 
function createEvent<E extends ClientNameEvents | CustomEventsKeys>(data: {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}): {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent } from 'seyfert';

export default 
createEvent<"messagePollVoteAdd">(data: {
    data: {
        name: "messagePollVoteAdd";
        once?: boolean;
    };
    run: (args_0: {
        userId: string;
        channelId: string;
        messageId: string;
        guildId?: string | undefined;
        answerId: number;
    }, args_1: UsingClient, args_2: number) => any;
}): {
    ...;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent({
    
data: {
    name: "messagePollVoteAdd";
    once?: boolean;
}
data: { 
name: "messagePollVoteAdd"
name: 'messagePollVoteAdd' },
    
run: (args_0: {
    userId: string;
    channelId: string;
    messageId: string;
    guildId?: string | undefined;
    answerId: number;
}, args_1: UsingClient, args_2: number) => any
run: (
data: {
    userId: string;
    channelId: string;
    messageId: string;
    guildId?: string | undefined;
    answerId: number;
}
data) => {
        // Puedes hacer lo que quieras con los datos
        
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(`The user: ${
data: {
    userId: string;
    channelId: string;
    messageId: string;
    guildId?: string | undefined;
    answerId: number;
}
data.
userId: string
userId} added a vote to the poll: ${
data: {
    userId: string;
    channelId: string;
    messageId: string;
    guildId?: string | undefined;
    answerId: number;
}
data.
messageId: string
messageId}`);
    },
});

import { 
function createEvent<E extends ClientNameEvents | CustomEventsKeys>(data: {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}): {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent } from 'seyfert';

export default 
createEvent<"messagePollVoteRemove">(data: {
    data: {
        name: "messagePollVoteRemove";
        once?: boolean;
    };
    run: (args_0: {
        userId: string;
        channelId: string;
        messageId: string;
        guildId?: string | undefined;
        answerId: number;
    }, args_1: UsingClient, args_2: number) => any;
}): {
    ...;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent({
    
data: {
    name: "messagePollVoteRemove";
    once?: boolean;
}
data: { 
name: "messagePollVoteRemove"
name: 'messagePollVoteRemove' },
    
run: (args_0: {
    userId: string;
    channelId: string;
    messageId: string;
    guildId?: string | undefined;
    answerId: number;
}, args_1: UsingClient, args_2: number) => any
run: (
data: {
    userId: string;
    channelId: string;
    messageId: string;
    guildId?: string | undefined;
    answerId: number;
}
data) => {
        // Puedes hacer lo que quieras con los datos
        
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(`The user: ${
data: {
    userId: string;
    channelId: string;
    messageId: string;
    guildId?: string | undefined;
    answerId: number;
}
data.
userId: string
userId} removed a vote to the poll: ${
data: {
    userId: string;
    channelId: string;
    messageId: string;
    guildId?: string | undefined;
    answerId: number;
}
data.
messageId: string
messageId}`);
    },
});

Fin del evento

La forma de comprobar cuándo finaliza una encuesta es utilizando el evento messageUpdate.

He aquí un ejemplo rápido que editará el mensaje cuando se complete una encuesta:

import { 
function createEvent<E extends ClientNameEvents | CustomEventsKeys>(data: {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}): {
    data: {
        name: E;
        once?: boolean;
    };
    run: (...args: ResolveEventParams<E>) => any;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent } from 'seyfert';

export default 
createEvent<"messageUpdate">(data: {
    data: {
        name: "messageUpdate";
        once?: boolean;
    };
    run: (args_0: [message: Omit<Message, "tts"> & {
        tts: false;
    }, old: Message | undefined], args_1: UsingClient, args_2: number) => any;
}): {
    ...;
}
Creates an event with the specified data and run function.
@param ― data - The event data.
@returns ― The created event.
@example const myEvent = createEvent({
data: { name: 'ready', once: true },
run: (user, client, shard) => {
client.logger.info(Start ${user.username} on shard #${shard});
}
});
createEvent({
    
data: {
    name: "messageUpdate";
    once?: boolean;
}
data: { 
name: "messageUpdate"
name: 'messageUpdate' },
    // Esto es [newMessage, oldMessage]
    // Pero en este ejemplo sólo necesitamos newMessage
    
run: (args_0: [message: Omit<Message, "tts"> & {
    tts: false;
}, old: Message | undefined], args_1: UsingClient, args_2: number) => any
run: ([
newMessage: Omit<Message, "tts"> & {
    tts: false;
}
newMessage]) => {
        if (
newMessage: Omit<Message, "tts"> & {
    tts: false;
}
newMessage.
poll?: Poll | undefined
poll?.
results?: {
    isFinalized: boolean;
    answerCounts: {
        id: number;
        count: number;
        meVoted: boolean;
    }[];
} | undefined
results?.
isFinalized: boolean | undefined
isFinalized) {
            
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(`The poll with the id: ${
newMessage: Omit<Message, "tts"> & {
    tts: false;
}
newMessage.
id: string
id} is ended`)
        }
    },
});

Comandos

Ejemplos rápidos de cómo crear una encuesta y cómo finalizarla.

Supongamos que tienes la siguiente estructura de directorios:

src
Directorycommands
- Directorypoll
  - start.command.ts
  - end.command.ts
  - parent.ts
index.ts
seyfert.config.mjs
package.json
tsconfig.json

import { 
function AutoLoad(): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        __autoload: boolean;
    };
} & T
AutoLoad, 
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare, 
class Command
Command } from 'seyfert';

@
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare({
    
name: string
name: 'poll',
    
description: string
description: 'Poll command!',
})
@
function AutoLoad(): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        __autoload: boolean;
    };
} & T
AutoLoad()
export default class 
class PollCommand
PollCommand extends 
class Command
Command {}

import {
    type 
class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
CommandContext,
    
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare,
    type 
type OKFunction<T> = (value: T) => void
OKFunction,
    
function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        options: SubCommand[] | CommandOption[];
    };
} & T
Options,
    
class PollBuilder
PollBuilder,
    
class SubCommand
SubCommand,
    
function createStringOption<R extends boolean, C extends SeyfertChoice<string>[] = SeyfertChoice<string>[], VC = never>(data: SeyfertStringOption<C, R, VC>): {
    readonly type: ApplicationCommandOptionType.String;
    readonly required?: R | undefined;
    readonly choices?: C | undefined;
    readonly value?: ValueCallback<ApplicationCommandOptionType.String, C, VC> | undefined;
    readonly description: string;
    readonly description_localizations?: APIApplicationCommandBasicOption["description_localizations"];
    readonly name_localizations?: APIApplicationCommandBasicOption["name_localizations"];
    readonly locales?: {
        name?: FlatObjectKeys<DefaultLocale>;
        description?: FlatObjectKeys<DefaultLocale>;
    };
    readonly autocomplete?: AutocompleteCallback;
    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
    readonly min_length?: number;
    readonly max_length?: number;
}
createStringOption,
    
function createNumberOption<R extends boolean, C extends SeyfertChoice<number>[] = SeyfertChoice<number>[], VC = never>(data: SeyfertNumberOption<C, R, VC>): {
    readonly type: ApplicationCommandOptionType.Number;
    readonly required?: R | undefined;
    readonly choices?: C | undefined;
    readonly value?: ValueCallback<ApplicationCommandOptionType.Number, C, VC> | undefined;
    readonly description: string;
    readonly description_localizations?: APIApplicationCommandBasicOption["description_localizations"];
    readonly name_localizations?: APIApplicationCommandBasicOption["name_localizations"];
    readonly locales?: {
        name?: FlatObjectKeys<DefaultLocale>;
        description?: FlatObjectKeys<DefaultLocale>;
    };
    readonly autocomplete?: AutocompleteCallback;
    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
    readonly min_value?: number;
    readonly max_value?: number;
}
createNumberOption,
} from 'seyfert';
import { 
enum MessageFlags
https://discord.com/developers/docs/resources/channel#message-object-message-flags
MessageFlags } from 'seyfert/lib/types';

const 
const options: {
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}
options = {
    
question: {
    readonly type: ApplicationCommandOptionType.String;
    readonly required?: true | undefined;
    readonly choices?: SeyfertChoice<string>[] | undefined;
    ... 8 more ...;
    readonly max_length?: number;
}
question: 
createStringOption<true, SeyfertChoice<string>[], never>(data: SeyfertStringOption<SeyfertChoice<string>[], true, never>): {
    readonly type: ApplicationCommandOptionType.String;
    ... 10 more ...;
    readonly max_length?: number;
}
createStringOption({
        
SeyfertBaseChoiceableOption<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? SeyfertChoice<ChoiceableValues[T]>[] : never, R = boolean, VC = never>.description: string
description: 'Poll question.',
        
SeyfertBaseChoiceableOption<ApplicationCommandOptionType.String, SeyfertChoice<string>[], true, never>.required?: true | undefined
required: true,
    }),
    
answers: {
    readonly type: ApplicationCommandOptionType.String;
    readonly required?: true | undefined;
    readonly choices?: SeyfertChoice<string>[] | undefined;
    ... 8 more ...;
    readonly max_length?: number;
}
answers: 
createStringOption<true, SeyfertChoice<string>[], string[] | null>(data: SeyfertStringOption<SeyfertChoice<string>[], true, string[] | null>): {
    ...;
}
createStringOption({
        
SeyfertBaseChoiceableOption<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? SeyfertChoice<ChoiceableValues[T]>[] : never, R = boolean, VC = never>.description: string
description: 'Poll answers separated by commas.',
        
SeyfertBaseChoiceableOption<ApplicationCommandOptionType.String, SeyfertChoice<string>[], true, string[] | null>.required?: true | undefined
required: true,
        // Esto se puede mejorar, pero es un ejemplo rápido
        
SeyfertBaseChoiceableOption<ApplicationCommandOptionType.String, SeyfertChoice<string>[], true, string[] | null>.value?: ValueCallback<ApplicationCommandOptionType.String, SeyfertChoice<string>[], string[] | null> | undefined
value: ({ 
value: string
value }, 
ok: OKFunction<string[] | null>
ok: 
type OKFunction<T> = (value: T) => void
OKFunction<string[] | null>) => {
            // Esto es para tener más opciones en la encuesta
            // Ejemplo: ganyu, supremacía
            const 
const answers: string[]
answers = 
value: string
value.
String.split(separator: string | RegExp, limit?: number): string[] (+1 overload)
Split a string into substrings using the specified separator and return them as an array.
@param ― separator A string that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned.
@param ― limit A value used to limit the number of elements returned in the array.
split(', ');
            if (!
const answers: string[]
answers.
Array<string>.length: number
Gets or sets the length of the array. This is a number one higher than the highest index in the array.
length) return 
ok: (value: string[] | null) => void
ok(null);

            return 
ok: (value: string[] | null) => void
ok(
const answers: string[]
answers);
        },
    }),
    // La duración de la encuesta en horas.
    // Ejemplo: 1, 2, 5...
    
hours: {
    readonly type: ApplicationCommandOptionType.Number;
    readonly required?: boolean | undefined;
    readonly choices?: SeyfertChoice<...>[] | undefined;
    ... 8 more ...;
    readonly max_value?: number;
}
hours: 
createNumberOption<boolean, SeyfertChoice<number>[], never>(data: SeyfertNumberOption<SeyfertChoice<number>[], boolean, never>): {
    readonly type: ApplicationCommandOptionType.Number;
    ... 10 more ...;
    readonly max_value?: number;
}
createNumberOption({
        
SeyfertBaseChoiceableOption<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? SeyfertChoice<ChoiceableValues[T]>[] : never, R = boolean, VC = never>.description: string
description: 'The duration of the poll.'
    }),
};

@
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare({
    
name: string
name: 'start',
    
description: string
description: 'Create a new poll.',
})
@
function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        options: SubCommand[] | CommandOption[];
    };
} & T
Options(
const options: {
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}
options)
export default class 
class StartPoll
StartPoll extends 
class SubCommand
SubCommand {
    async 
StartPoll.run(ctx: CommandContext<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}>): Promise<...>
run(
ctx: CommandContext<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}, never>
ctx: 
class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
CommandContext<typeof 
const options: {
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}
options>) {
        const { 
const options: ContextOptions<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}>
options } = 
ctx: CommandContext<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}, never>
ctx;
        const { 
const question: string
question, 
const answers: string[] | null
answers } = 
const options: ContextOptions<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}>
options;

        const 
const channel: AllChannels
channel = await 
ctx: CommandContext<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}, never>
ctx.
CommandContext<{ question: { readonly type: ApplicationCommandOptionType.String; readonly required?: true | undefined; ... 9 more ...; readonly max_length?: number; }; answers: { ...; }; hours: { ...; }; }, never>.channel(mode?: "rest" | "flow"): Promise<AllChannels> (+1 overload)
channel('rest');

        if (!
const channel: AllChannels
channel.
BaseNoEditableChannel<T extends ChannelType>.isTextGuild(): this is TextGuildChannel
isTextGuild()) return;
        if (!
const answers: string[] | null
answers)
            return 
ctx: CommandContext<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}, never>
ctx.
CommandContext<{ question: { readonly type: ApplicationCommandOptionType.String; readonly required?: true | undefined; ... 9 more ...; readonly max_length?: number; }; answers: { ...; }; hours: { ...; }; }, never>.editOrReply<false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, withResponse?: false | undefined): Promise<...>
editOrReply({
                
flags?: MessageFlags | undefined
Message flags combined as a bitfield
flags: 
enum MessageFlags
https://discord.com/developers/docs/resources/channel#message-object-message-flags
MessageFlags.
function (enum member) MessageFlags.Ephemeral = 64
This message is only visible to the user who invoked the Interaction
Ephemeral,
                
content: string
content: 'Answers needs to be separed by commas!',
            });

        const 
const hours: number
hours = 
const options: ContextOptions<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}>
options.
hours?: number | undefined
hours ?? 1;

        // Tenemos un nuevo constructor para las encuestas.
        // PollBuilder hace que sea más fácil crear encuestas.
        const 
const newPoll: PollBuilder
newPoll = new 
new PollBuilder(data?: DeepPartial<RESTAPIPollCreate>): PollBuilder
PollBuilder()
            .
PollBuilder.allowMultiselect(value?: boolean): PollBuilder
allowMultiselect(true)
            .
PollBuilder.setQuestion(data: PollMedia): PollBuilder
setQuestion({ 
text?: string | undefined
The text of the field
The maximum length is 300 for the question, and 55 for any answer
text: 
const question: string
question })
            .
PollBuilder.setAnswers(...answers: RestOrArray<PollMedia>): PollBuilder
setAnswers(
                // Las respuestas tienen un máximo de 10
                
const answers: string[]
answers.
Array<string>.map<{
    text: string;
    emoji: string;
}>(callbackfn: (value: string, index: number, array: string[]) => {
    text: string;
    emoji: string;
}, thisArg?: any): {
    text: string;
    emoji: string;
}[]
Calls a defined callback function on each element of an array, and returns an array that contains the results.
@param ― callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
@param ― thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
map((
text: string
text) => ({
                    
text: string
text,
                    // También puedes añadir emojis
                    
emoji: string
emoji: '🐐'
                }))
            )
            .
PollBuilder.setDuration(hours: number): PollBuilder
setDuration(
const hours: number
hours);

        await 
const channel: TextGuildChannel
channel.
MessagesMethods.messages: {
    write: (body: MessageCreateBodyRequest) => Promise<MessageStructure>;
    edit: (messageId: string, body: MessageUpdateBodyRequest) => Promise<MessageStructure>;
    ... 4 more ...;
    list: (fetchOptions: RESTGetAPIChannelMessagesQuery) => Promise<MessageStructure[]>;
}
messages.
write: (body: MessageCreateBodyRequest) => Promise<MessageStructure>
write({
            
content?: string | undefined
The message contents (up to 2000 characters)
content: 'New poll started.',
            
SendResolverProps.poll?: PollBuilder | RESTAPIPollCreate | undefined
poll: 
const newPoll: PollBuilder
newPoll
        });

        await 
ctx: CommandContext<{
    question: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
    answers: {
        ...;
    };
    hours: {
        ...;
    };
}, never>
ctx.
CommandContext<{ question: { readonly type: ApplicationCommandOptionType.String; readonly required?: true | undefined; ... 9 more ...; readonly max_length?: number; }; answers: { ...; }; hours: { ...; }; }, never>.editOrReply<false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, withResponse?: false | undefined): Promise<...>
editOrReply({
            
content: string
content: `Poll started in the channel: ${
const channel: TextGuildChannel
channel.
BaseNoEditableChannel<ChannelType>.toString(): `<#${string}>`
Returns a string representation of an object.
toString()}`,
            
flags?: MessageFlags | undefined
Message flags combined as a bitfield
flags: 
enum MessageFlags
https://discord.com/developers/docs/resources/channel#message-object-message-flags
MessageFlags.
function (enum member) MessageFlags.Ephemeral = 64
This message is only visible to the user who invoked the Interaction
Ephemeral,
        });
    }
}

import {
    type 
class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
CommandContext,
    
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare,
    
function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        options: SubCommand[] | CommandOption[];
    };
} & T
Options,
    
class SubCommand
SubCommand,
    
function createStringOption<R extends boolean, C extends SeyfertChoice<string>[] = SeyfertChoice<string>[], VC = never>(data: SeyfertStringOption<C, R, VC>): {
    readonly type: ApplicationCommandOptionType.String;
    readonly required?: R | undefined;
    readonly choices?: C | undefined;
    readonly value?: ValueCallback<ApplicationCommandOptionType.String, C, VC> | undefined;
    readonly description: string;
    readonly description_localizations?: APIApplicationCommandBasicOption["description_localizations"];
    readonly name_localizations?: APIApplicationCommandBasicOption["name_localizations"];
    readonly locales?: {
        name?: FlatObjectKeys<DefaultLocale>;
        description?: FlatObjectKeys<DefaultLocale>;
    };
    readonly autocomplete?: AutocompleteCallback;
    readonly onAutocompleteError?: OnAutocompleteErrorCallback;
    readonly min_length?: number;
    readonly max_length?: number;
}
createStringOption
} from 'seyfert';
import { 
enum MessageFlags
https://discord.com/developers/docs/resources/channel#message-object-message-flags
MessageFlags } from 'seyfert/lib/types';

const 
const options: {
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}
options = {
    
message: {
    readonly type: ApplicationCommandOptionType.String;
    readonly required?: true | undefined;
    readonly choices?: SeyfertChoice<string>[] | undefined;
    ... 8 more ...;
    readonly max_length?: number;
}
message: 
createStringOption<true, SeyfertChoice<string>[], never>(data: SeyfertStringOption<SeyfertChoice<string>[], true, never>): {
    readonly type: ApplicationCommandOptionType.String;
    ... 10 more ...;
    readonly max_length?: number;
}
createStringOption({
        
SeyfertBaseChoiceableOption<T extends keyof ReturnOptionsTypes, C = T extends ChoiceableTypes ? SeyfertChoice<ChoiceableValues[T]>[] : never, R = boolean, VC = never>.description: string
description: 'The message id of the poll',
        
SeyfertBaseChoiceableOption<ApplicationCommandOptionType.String, SeyfertChoice<string>[], true, never>.required?: true | undefined
required: true,
    }),
};

@
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare({
    
name: string
name: 'end',
    
description: string
description: 'End a poll.',
})
@
function Options(options: (new () => SubCommand)[] | OptionsRecord): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        options: SubCommand[] | CommandOption[];
    };
} & T
Options(
const options: {
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}
options)
export default class 
class EndPoll
EndPoll extends 
class SubCommand
SubCommand {
    async 
EndPoll.run(ctx: CommandContext<{
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        ... 9 more ...;
        readonly max_length?: number;
    };
}>): Promise<...>
run(
ctx: CommandContext<{
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}, never>
ctx: 
class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
CommandContext<typeof 
const options: {
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}
options>) {
        const { 
const options: ContextOptions<{
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}>
options, 
const client: UsingClient
client } = 
ctx: CommandContext<{
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}, never>
ctx;
        const { 
message: string
message: 
const messageId: string
messageId } = 
const options: ContextOptions<{
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}>
options;

        await 
const client: UsingClient
client.
BaseClient.messages: MessageShorter
messages.
MessageShorter.endPoll(channelId: string, messageId: string): Promise<MessageStructure>
endPoll(
ctx: CommandContext<{
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}, never>
ctx.
CommandContext<{ message: { readonly type: ApplicationCommandOptionType.String; readonly required?: true | undefined; readonly choices?: SeyfertChoice<...>[] | undefined; ... 8 more ...; readonly max_length?: number; }; }, never>.channelId: string
channelId, 
const messageId: string
messageId);
        await 
ctx: CommandContext<{
    message: {
        readonly type: ApplicationCommandOptionType.String;
        readonly required?: true | undefined;
        readonly choices?: SeyfertChoice<...>[] | undefined;
        ... 8 more ...;
        readonly max_length?: number;
    };
}, never>
ctx.
CommandContext<{ message: { readonly type: ApplicationCommandOptionType.String; readonly required?: true | undefined; readonly choices?: SeyfertChoice<...>[] | undefined; ... 8 more ...; readonly max_length?: number; }; }, never>.editOrReply<false>(body: InteractionCreateBodyRequest | InteractionMessageUpdateBodyRequest, withResponse?: false | undefined): Promise<...>
editOrReply({
            
flags?: MessageFlags | undefined
Message flags combined as a bitfield
flags: 
enum MessageFlags
https://discord.com/developers/docs/resources/channel#message-object-message-flags
MessageFlags.
function (enum member) MessageFlags.Ephemeral = 64
This message is only visible to the user who invoked the Interaction
Ephemeral,
            
content: string
content: 'Poll ended.',
        });
    }
}