hiro

type Component struct {
	Ctx `json:"-"`
}

type Ctx interface {
	Auth(dbname ...string) auth.Manager
	Cache() cache.Client
	Config() config.Config
	Continue() error
	Cookie() cookie.Cookie
	Create() Factory
	Csrf() csrf.Csrf
	DB(dbname ...string) *esquel.DB
	Dev() Dev
	Email() mailer.Mailer
	Export() Export
	Files() filesystem.Client
	Flash() Flash
	Generate() Generator
	Lang() Lang
	Log() logger.Log
	Page() Page
	Parse() parser.Parse
	Request() Request
	Response() Response
	State() State
	Translate(key string, args ...map[string]any) string
	Ws(name string) *Ws
}

type Dev interface {
	Debug(values ...any) error
	MustDebug(values ...any)
}

type Export interface {
	Csv() exporter.Csv
	Excel() exporter.Excel
	Pdf() exporter.Pdf
}

type Factory interface {
	Component(ct MandatoryComponent) gox.Node
	Defer(link string, nodes ...gox.Node) gox.Node
	Form(fields ...*form.FieldBuilder) *form.Builder
}

type Flash interface {
	Get() ([]Message, error)
	Success(title, value string) error
	Warning(title, value string) error
	Error(title, value string) error

	MustGet() []Message
	MustSuccess(title, value string)
	MustWarning(title, value string)
	MustError(title, value string)
}

type Generator interface {
	Assets(name string) gox.Node
	Action(name string, args ...Map) string
	Current(qpm ...Map) string
	Csrf(name string) gox.Node
	Link(name string, args ...Map) string
	PublicUrl(path string) string
	Query(args Map) string
	SwitchLang(langCode string) string
}

type Handler func(c Ctx) error

type Hiro interface {
	Router
	Log(handler logger.Handler) Hiro
	DynamicHandler(handler Handler) Hiro
	Layout() LayoutManager
	Run(address string)
	Mux() *http.ServeMux
	Plugin(plugin Plugin) Hiro
}

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

type Intercept interface {
	Error() error
	Status() int
}

type Lang interface {
	Main() string
	Exists() bool
	Current() string
}

type LayoutManager interface {
	Add(name string, layout layoutFactory) LayoutManager
}

type MandatoryComponent interface {
	gox.Node
	Name() string
	Mount()
}

type Map map[string]any

type Message struct {
	Type  string `json:"type"`
	Title string `json:"title"`
	Value string `json:"value"`
}

type Page interface {
	Get() PageGetter
	Set() PageSetter
}

type PageGetter interface {
	Title() string
	Description() string
	Keywords() string
	Metas() [][2]string
}

type PageSetter interface {
	Title(title string) PageSetter
	Description(description string) PageSetter
	Keywords(keywords ...string) PageSetter
	Meta(name, content string) PageSetter
}

type Plugin struct {
	Name    string
	Locales map[string]map[string]string
}

type Request interface {
	Action() string
	ContentType() string
	Form() url.Values
	Header() http.Header
	Host() string
	Ip() string
	Is() RequestIs
	Method() string
	Name() string
	Origin() string
	Parsed() Map
	Path() string
	PathValue(key string, defaultValue ...string) string
	QueryParam(key string, defaultValue ...string) string
	QueryMap() Map
	PathMap() Map
	Protocol() string
	Raw() *http.Request
	UserAgent() string
}

type RequestIs interface {
	Get() bool
	Post() bool
	Put() bool
	Patch() bool
	Delete() bool
	Action(actionName ...string) bool
	Active(routeName string) bool
	Hx() bool
	Options() bool
	Head() bool
	Connect() bool
	Trace() bool
	Form() bool
}

type Response interface {
	sender.ExtendableSend
	Status(statusCode int) Response
	Refresh() error
	Render(nodes ...gox.Node) error
	Intercept() Intercept
}

type Route struct {
	Lang       string
	Path       string
	Name       string
	Layout     layoutFactory
	Matcher    *regexp.Regexp
	Methods    []string
	Firewall   []firewall.Firewall
	PathValues []string
	Ws         socketer.Ws
	Components map[string]MandatoryComponent
}

type RouteConfig struct {
	Type  int
	Value any
}

type Router interface {
	Use(handler ...Handler) Router
	Static(path, dir string) Router
	Route(path any, handler Handler, config ...RouteConfig) Router
	Ws(path any, config ...RouteConfig) Router
	Group(path any, name ...string) Router
}

type Slice []Map

type State interface {
	Token() string
	Get(key string, target any, preserve ...bool) error
	Save(key string, value any) error
	Delete(key string) error

	MustGet(key string, target any, preserve ...bool)
	MustSave(key string, value any)
	MustDelete(key string)
}

type TestCtxParam struct {
	Config         config.Config
	Request        *http.Request
	ResponseWriter http.ResponseWriter
	MatchedRoute   *Route
	Routes         *[]*Route
}

type TestRouteParam struct {
	Config  *config.Config
	Method  string
	Path    string
	TempDir string
	Body    io.Reader
	Handler func(c Ctx) error
}

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