gommand

type ArgTransformer struct {
	// Greedy defines if the parser should keep going until an argument fails.
	Greedy bool

	// Optional defines if the argument is optional. This can be mixed with greedy or remainder.
	// This has to be either at the end of the argument list or followed by other optional arguments (if you don't combine with Remainder).
	Optional bool

	// Remainder defines if it should just parse the rest of the arguments.
	// Remainders need to be at the end of a command.
	Remainder bool

	// Function is used to transform the argument. The function should error if this is not possible.
	Function func(ctx *Context, Arg string) (interface{}, error)

	// Default is the value the arg will have if it isn't supplied by the user.
	// This will not be used in case of an error from the transformer function, only when no argument is passed by the user.
	// Similarly to optional, this either has to be one of the end arguments (or followed by other default arguments only).
	Default interface{}
}

type Category struct {
	Name                 string                `json:"name"`
	Description          string                `json:"description"`
	Cooldown             Cooldown              `json:"cooldown"`
	PermissionValidators []PermissionValidator `json:"-"`
	Middleware           []Middleware          `json:"-"`
}

type CategoryInterface interface {
	GetName() string
	GetDescription() string
	GetPermissionValidators() []func(ctx *Context) (string, bool) // If I change this to the PermissionValidator type, it triggers #25838 in Go.
	GetMiddleware() []Middleware
	GetCooldown() Cooldown
}

type ChannelCooldown struct {

	// MaxRuns is the maximum amount of times a command can be ran by a channel until each usage expires.
	MaxRuns uint

	// UsageExpires is used to define how long until a usage expires (and is therefore not counted in the cooldown).
	UsageExpires time.Duration
	// contains filtered or unexported fields
}

type ChildMenuOptions struct {
	Embed        *disgord.Embed `json:"embed"`
	Button       *MenuButton    `json:"button"`
	BeforeAction func()         `json:"-"`
	AfterAction  func()         `json:"-"`
}

type Command struct {
	Name                 string                   `json:"name"`
	Aliases              []string                 `json:"aliases"`
	Description          string                   `json:"description"`
	Usage                string                   `json:"usage"`
	Category             CategoryInterface        `json:"category"`
	Cooldown             Cooldown                 `json:"cooldown"`
	CommandAttributes    interface{}              `json:"commandAttributes"`
	PermissionValidators []PermissionValidator    `json:"-"`
	ArgTransformers      []ArgTransformer         `json:"-"`
	Middleware           []Middleware             `json:"-"`
	Function             func(ctx *Context) error `json:"-"`
	// contains filtered or unexported fields
}

type CommandBasics = commandBasics

type CommandBlank struct {
	// contains filtered or unexported fields
}

type CommandGroup struct {
	// Name is used to define the category name.
	Name string `json:"name"`

	// Aliases is used to define aliases for this command group.
	Aliases []string `json:"aliases"`

	// Description is used to define a group description.
	Description string `json:"description"`

	// Category is used to define a group category.
	Category CategoryInterface `json:"category"`

	// Cooldown is used to define a group cooldown.
	Cooldown Cooldown `json:"cooldown"`

	// PermissionValidators defines the permission validators for this group.
	PermissionValidators []PermissionValidator `json:"-"`

	// Middleware is used to define the sub-command middleware. Note that this applies to all items in the group.
	Middleware []Middleware `json:"-"`

	// NoCommandSpecified is the command to call when no command is specified.
	NoCommandSpecified CommandInterface
	// contains filtered or unexported fields
}

type CommandInterface interface {
	// Get the attributes of the command.
	GetName() string
	GetAliases() []string
	GetDescription() string
	GetUsage() string
	GetCooldown() Cooldown
	GetCategory() CategoryInterface
	GetPermissionValidators() []PermissionValidator
	GetArgTransformers() []ArgTransformer
	GetMiddleware() []Middleware

	// Initialisation function and command.
	Init()
	CommandFunction(ctx *Context) error
}

type CommandNotFound struct {
	// contains filtered or unexported fields
}

type CommandOnCooldown struct {
	Message string
}

type Context struct {
	ShardID          uint                   `json:"shardId"`
	Prefix           string                 `json:"prefix"`
	Message          *disgord.Message       `json:"message"`
	BotUser          *disgord.User          `json:"botUser"`
	Router           *Router                `json:"-"`
	Session          disgord.Session        `json:"session"`
	Command          CommandInterface       `json:"command"`
	RawArgs          string                 `json:"rawArgs"`
	Args             []interface{}          `json:"args"`
	WaitManager      *WaitManager           `json:"-"`
	MiddlewareParams map[string]interface{} `json:"middlewareParams"`
	State            interface{}            `json:"state"`
}

type Cooldown interface {
	// Init is ran on the insertion of the cooldown bucket into a command/category/attribute which has been added to the router.
	// Note that your struct should implement logic to make sure that Init only modifies the struct once since a cooldown might be shared across objects!
	Init()

	// Check should add one X (where X is what you're measuring) to the cooldown bucket and return true if the command should run.
	Check(ctx *Context) (message string, ok bool)

	// Clear should clear any command related ratelimits.
	Clear()
}

type CustomCommandsHandler = func(ctx *Context, cmdname string, parser *fastparse.Parser) (bool, error)

type EmbedLifetimeOptions struct {
	// The maximum time after which an embed is created for which it can exist.
	// After this time has passed, if it hasn't already then the menu will be deleted.
	MaximumLifetime time.Duration

	// The maximum time after an embed was last interacted with (reacted to) that it can exist for.
	// After this time has passed, if it hasn't already then the menu will be deleted.
	InactiveLifetime time.Duration

	// The function called before the menu should be deleted.
	BeforeDelete func()

	// The function called after the message is deleted (only if deleted through exceeded lifetime).
	// Called regardless of errors returned when deleting the message.
	AfterDelete func()
	// contains filtered or unexported fields
}

type EmbedMenu struct {
	Reactions *MenuReactions

	Embed    *disgord.Embed
	MenuInfo *MenuInfo
	// contains filtered or unexported fields
}

type ErrorHandler = func(ctx *Context, err error) bool

type GetState = func(ctx *Context) error

type GuildChannelRelationshipManagement interface {
	GetAllChannelIDs(GuildID disgord.Snowflake) []disgord.Snowflake
	AddChannelID(GuildID, ChannelID disgord.Snowflake)
	RemoveChannelID(GuildID, ChannelID disgord.Snowflake)
}

type GuildCooldown struct {

	// MaxRuns is the maximum amount of times a command can be ran in a guild until each usage expires.
	MaxRuns uint

	// UsageExpires is used to define how long until a usage expires (and is therefore not counted in the cooldown).
	UsageExpires time.Duration
	// contains filtered or unexported fields
}

type InMemoryMessageCacheStorageAdapter struct {
	// contains filtered or unexported fields
}

type IncorrectPermissions struct {
	// contains filtered or unexported fields
}

type InvalidArgCount struct {
	// contains filtered or unexported fields
}

type InvalidTransformation struct {
	Description string
}

type MenuButton struct {
	Emoji       string
	Name        string
	Description string
}

type MenuInfo struct {
	Author string
	Info   []string
}

type MenuReaction struct {
	Button   *MenuButton
	Function func(ChannelID, MessageID disgord.Snowflake, _ *EmbedMenu, client disgord.Session)
}

type MenuReactions struct {
	ReactionSlice []MenuReaction
}

type MessageCacheHandler struct {
	MessageCacheStorageAdapter MessageCacheStorageAdapter                                                        `json:"-"`
	BulkDeletedCallback        func(s disgord.Session, channelID disgord.Snowflake, messages []*disgord.Message) `json:""`
	DeletedCallback            func(s disgord.Session, msg *disgord.Message)                                     `json:"-"`
	UpdatedCallback            func(s disgord.Session, before, after *disgord.Message)                           `json:"-"`

	// Limit defines the amount of messages.
	// -1 = unlimited (not suggested if it's in-memory since it'll lead to memory leaks), 0 = default, >0 = user set maximum
	Limit int `json:"limit"`

	// IgnoreBots is whether or not messages from bots should be excluded from the message cache.
	IgnoreBots bool `json:"ignoreBots"`
}

type MessageCacheStorageAdapter interface {
	// Called when the router is created.
	Init()

	// Related to message caching.
	BulkGetAndDelete(ChannelID disgord.Snowflake, MessageIDs []disgord.Snowflake) []*disgord.Message
	GetAndDelete(ChannelID, MessageID disgord.Snowflake) *disgord.Message
	Delete(ChannelID, MessageID disgord.Snowflake)
	DeleteChannelsMessages(ChannelID disgord.Snowflake)
	Set(ChannelID, MessageID disgord.Snowflake, Message *disgord.Message, Limit uint)
	Update(ChannelID, MessageID disgord.Snowflake, Message *disgord.Message) (old *disgord.Message)

	// Handles guild removal. The behaviour of this changes depending on if GuildChannelRelationshipManagement is implemented.
	// If it is, this will just be used to remove all guild/channel relationships but not messages from the cache (that'll be done by running DeleteChannelsMessages with each channel ID).
	// If it isn't, it will remove all of the guilds messages from the cache.
	RemoveGuild(GuildID disgord.Snowflake)
}

type Middleware = func(ctx *Context) error

type PanicError struct {
	// contains filtered or unexported fields
}

type PermissionCheckSettings uint8

type PermissionValidator = func(ctx *Context) (string, bool)

type PrefixCheck = func(ctx *Context, r io.ReadSeeker) bool

type Router struct {
	PrefixCheck           PrefixCheck           `json:"-"`
	CustomCommandsHandler CustomCommandsHandler `json:"-"`

	MessageCacheHandler *MessageCacheHandler
	Cooldown            Cooldown
	GetState            GetState
	// contains filtered or unexported fields
}

type RouterConfig struct {
	MessageCacheHandler  *MessageCacheHandler
	PrefixCheck          PrefixCheck
	ErrorHandlers        []ErrorHandler
	PermissionValidators []PermissionValidator
	Middleware           []Middleware
	Cooldown             Cooldown
	GetState             GetState

	// The number if message pads which will be created in memory to allow for quicker parsing.
	// Please set this to -1 if you do not want any, 0 will default to 100.
	MessagePads int
}

type UserCooldown struct {

	// MaxRuns is the maximum amount of times a command can be ran by a user until each usage expires.
	MaxRuns uint

	// UsageExpires is used to define how long until a usage expires (and is therefore not counted in the cooldown).
	UsageExpires time.Duration
	// contains filtered or unexported fields
}

type WaitManager struct {
	// contains filtered or unexported fields
}