guilded.ts/dist/collectors/Collector.d.ts

A powerful NPM module that allows you to easily interact with the Guilded API.

/// <reference types="node" />
import { Collection } from '@discordjs/collection';
import EventEmitter from 'events';
import { Base } from '../structures/Base';
import { Client } from '../structures/Client';
/**
 * The collector of a data model.
 * @example new Collector(client);
 */
export declare class Collector<Model extends Base<any>> extends EventEmitter {
    readonly client: Client;
    readonly options: CollectorOptions<Model>;
    /** The collected data. */
    readonly collected: Collection<Model['id'], Model>;
    /** The date the collector was created. */
    readonly createdAt: Date;
    /** The date the collector was ended. */
    endedAt?: Date;
    /** The idle timeout for the collector. */
    private idleTimeout?;
    /**
     * @param client The client the collector belongs to.
     * @param options The options of the collector.
     */
    constructor(client: Client, options?: CollectorOptions<Model>);
    /** The timestamp the collector was created. */
    get createdTimestamp(): number;
    /** Whether the collector has ended. */
    get isEnded(): boolean;
    /** The timestamp the collector was ended. */
    get endedTimestamp(): number | undefined;
    /** The time the collector has been running. */
    get uptime(): number;
    /**
     * End the collector.
     * @example collector.end();
     */
    end(): void;
    /**
     * Collect a item.
     * @param item The item to collect.
     * @returns The collected item.
     * @example collector.collect(item);
     */
    collect(item: Model): Promise<Model | undefined>;
    /**
     * Dispose a collected item.
     * @param itemId The ID of the item to dispose.
     * @returns The disposed item.
     * @example collector.dispose('abc');
     */
    dispose(itemId: Model['id']): Model | undefined;
}
export interface Collector<Model extends Base<any>> {
    /** @ignore */
    on<Event extends keyof CollectorEvents<Model>>(event: Event, listener: (...args: CollectorEvents<Model>[Event]) => any): this;
    /** @ignore */
    once<Event extends keyof CollectorEvents<Model>>(event: Event, listener: (...args: CollectorEvents<Model>[Event]) => any): this;
    /** @ignore */
    off<Event extends keyof CollectorEvents<Model>>(event: Event, listener: (...args: CollectorEvents<Model>[Event]) => any): this;
    emit<Event extends keyof CollectorEvents<Model>>(event: Event, ...args: CollectorEvents<Model>[Event]): boolean;
}
/** The collector events. */
export interface CollectorEvents<Model extends Base<any>> {
    /** Emitted when data is collected. */
    collect: [item: Model];
    /** Emitted when a collected item is disposed. */
    dispose: [item: Model];
    /** Emitted when the collector is finished collecting data. */
    end: [collected: Collection<Model['id'], Model>];
}
/** The options for the collector. */
export interface CollectorOptions<Model extends Base<any>> {
    /** The filter to apply to the collector. */
    filter?: CollectorFilter<Model>;
    /** The time in milliseconds to wait before ending the collector. */
    time?: number;
    /** The time in milliseconds to wait before ending the collector due to it being idle. */
    idle?: number;
    /** The max amount of items to collect. */
    max?: number;
    /** Whether to dispose data when it is deleted. */
    dispose?: boolean;
}
/** The filter to apply to the collector. */
export declare type CollectorFilter<Model extends Base> = (item: Model) => boolean | Promise<boolean>;
//# sourceMappingURL=Collector.d.ts.map