src/core/CommandArgumentParserInterface.ts

import { Awaitable, Message } from "discord.js";

export type ParsingState = {
    argv: string[];
    args: string[];
    parsedArgs: Record<string | number, any>;
    index: number;
    currentArg: string | undefined;
    rule: ValidationRule;
    parseOptions: ParseOptions;
    type: ArgumentType;
};

export enum ArgumentType {
    String,
    Number,
    Integer,
    Float,
    User,
    Role,
    Member,
    Channel,
    StringRest,
    Snowflake,
    Link,
    TimeInterval
}

export type ValidationErrorType =
    | "required"
    | "type:invalid"
    | "entity:null"
    | "number:range:min"
    | "number:range:max"
    | "number:range"
    | "time:range:min"
    | "time:range:max"
    | "time:range"
    | "string:length:min"
    | "string:length:max"
    | "string:rest:length:min"
    | "string:rest:length:max"
    | "string:empty";

export type ValidationRuleErrorMessages = { [K in ValidationErrorType]?: string };
export type ValidationRule = {
    types: readonly ArgumentType[];
    optional?: boolean;
    default?: any;
    name?: string;
    errors?: ValidationRuleErrorMessages;
    number?: {
        min?: number;
        max?: number;
    };
    string?: {
        maxLength?: number;
        minLength?: number;
        notEmpty?: boolean;
    };
    time?: {
        unit?: "ms" | "s";
        min?: number;
        max?: number;
    };
    link?: {
        urlObject?: boolean;
    };
    entity?:
        | boolean
        | {
              notNull?: boolean;
          };
};

export type ParseOptions = {
    input: string;
    message?: Message;
    rules: readonly ValidationRule[];
    prefix: string;
};

export enum ParserJump {
    Next,
    Break,
    Steps
}

export type ParseResult<T = any> = {
    jump?: ParserJump;
    steps?: number;
    result?: T;
};

export default interface CommandArgumentParserInterface {
    parse(options: ParseOptions): Awaitable<Record<string | number, any>>;
}
1	import { Awaitable, Message } from "discord.js";
2
3	export type ParsingState = {
4	argv: string[];
5	args: string[];
6	parsedArgs: Record<string \| number, any>;
7	index: number;
8	currentArg: string \| undefined;
9	rule: ValidationRule;
10	parseOptions: ParseOptions;
11	type: ArgumentType;
12	};
13
14	export enum ArgumentType {
15	String,
16	Number,
17	Integer,
18	Float,
19	User,
20	Role,
21	Member,
22	Channel,
23	StringRest,
24	Snowflake,
25	Link,
26	TimeInterval
27	}
28
29	export type ValidationErrorType =
30	\| "required"
31	\| "type:invalid"
32	\| "entity:null"
33	\| "number:range:min"
34	\| "number:range:max"
35	\| "number:range"
36	\| "time:range:min"
37	\| "time:range:max"
38	\| "time:range"
39	\| "string:length:min"
40	\| "string:length:max"
41	\| "string:rest:length:min"
42	\| "string:rest:length:max"
43	\| "string:empty";
44
45	export type ValidationRuleErrorMessages = { [K in ValidationErrorType]?: string };
46	export type ValidationRule = {
47	types: readonly ArgumentType[];
48	optional?: boolean;
49	default?: any;
50	name?: string;
51	errors?: ValidationRuleErrorMessages;
52	number?: {
53	min?: number;
54	max?: number;
55	};
56	string?: {
57	maxLength?: number;
58	minLength?: number;
59	notEmpty?: boolean;
60	};
61	time?: {
62	unit?: "ms" \| "s";
63	min?: number;
64	max?: number;
65	};
66	link?: {
67	urlObject?: boolean;
68	};
69	entity?:
70	\| boolean
71	\| {
72	notNull?: boolean;
73	};
74	};
75
76	export type ParseOptions = {
77	input: string;
78	message?: Message;
79	rules: readonly ValidationRule[];
80	prefix: string;
81	};
82
83	export enum ParserJump {
84	Next,
85	Break,
86	Steps
87	}
88
89	export type ParseResult<T = any> = {
90	jump?: ParserJump;
91	steps?: number;
92	result?: T;
93	};
94
95	export default interface CommandArgumentParserInterface {
96	parse(options: ParseOptions): Awaitable<Record<string \| number, any>>;
97	}