Solid/Router

type Route() = interface HtmlElement

val path: string
// overload:
val paths: string array

val component': TagValue

val matchFilters: obj

val preload: RoutePreloadFunc

type RoutePreloadFunc = RoutePreloadFuncArgs -> unit

type RoutePreloadFuncArgs = interface

member ``params``: obj

member location: Location

member intent: Intent

type Intent

| Initial

| Native

| Navigate

| Preload

type Location = inherit Path

member query: obj

member state: obj option

member key: string

type Path = interface

member pathname: string

member search: string

member hash: string

type Router() = interface HtmlElement

val root: TagValue

val base': string

val actionBase: string

val preload: bool

val explicitLinks: bool

val url: string

val children: Route
val children: RootConfig[]

type MemoryHistory

member get(): string

member set(value: string, ?scroll: bool, ?replace: bool): unit

member back(): _

member forward(): _

member go(int): unit

member listen(string -> unit): Accessor<unit>

type MemoryRouter() = inherit Router()

val history: MemoryHistory

[<Pojo>]
type RootConfig (
    path: string,
    ``component``: HtmlElement
    )

type HashRouter = Router

[<Pojo>]
type PreloadData (preloadData: bool)

type A() = interface RegularNode

val href: string

val noScroll: bool

val replace: bool

val state: obj

val activeClass: string

val inactiveClass: string

val end': bool

type Navigate() = interface RegularNode

val href: string

val state: obj

type SolidAction<'Input, 'Result>

abstract url: string

abstract with': 'Input -> string

type Submission<'Input, 'Result>

abstract input: 'Input
abstract result: 'Result option
abstract error: obj
abstract pending: bool
abstract url: string
abstract clear: (unit -> unit)
abstract retry: (unit -> unit)

type AsyncAccessor<'T>

abstract Invoke: unit -> 'T

abstract latest: 'T

type Query<'Input, 'Output>

abstract Invoke: 'Input -> 'Output
abstract key: string
abstract keyFor: 'Input -> string

let action<'Input, 'Output> (
    handler: 'Input -> Promise<'Output>,
    ?name: string,
    ?onComplete: Submission<'Input, Output> -> unit
    ): SolidAction<'Input, 'Output>

let useAction<'Input, 'Result>(
    action: SolidAction<'Input, 'Result>
    ): 'Input -> 'Result

let useSubmission<'Input>(
    action: SolidAction<'Input, unit>,
    ?filter: 'Input -> bool
    ): Submission<'Input, unit>

let useSubmissions<'Input>(
    action: SolidAction<'Input, unit>,
    filter: 'Input -> bool
    ): Submission<'Input, unit> array

let createAsync<'T> (
    fn: 'T option -> Promise<'T>,
    ?name: string,
    ?initialValue: 'T,
    ?deferStream: bool,
    ?onHydrated: unit -> unit,
    ?ssrLoadFrom: string,
    ?storage: unit -> Signal<'T>
    ): Accessor<'T>

let createAsyncWithLatest<'T> (
    // ...
    ): AsyncAccessor<'T>

let createAsyncStore<'T>(
    fn: 'T option -> Promise<'T>,
    ?name: string,
    ?initialValue: 'T,
    ?deferStream: bool,
    ?onHydrated: unit -> unit,
    ?ssrLoadFrom: string,
    ?storage: unit -> Signal<'T>
    ): Accessor<'T>

let createAsyncStoreWithLatest<'T>(
    // ...
    ): AsyncAccessor<'T>

let query<'Input, 'Output>(
    fn: FSharpFunc<'Input, 'Output>,
    ?name: string
    ): FSharpFunc<'Input, 'Output>

let query'<'Input, 'Output>(
    fn: FSharpFunc<'Input, 'Output>,
    ?name: string
    ): Query<'Input, 'Output>

let revalidate(
    key: string,
    ?force: bool
    ): unit

let createMemoryHistory(): MemoryHistory

let useNavigate(): Navigator

type Navigator = interface

member Invoke: (``to``: string) * (?options: NavigateOptions) -> unit

member InvokeOptions:
    ``to``: string *
    ?resolve: bool *
    ?replace: bool *
    ?scroll: bool *
    ?state: obj
    -> unit

member Invoke: delta: float -> unit

let useLocation(): Location

let useIsRouting(): unit -> bool

let useMatch(
    fn: unit -> string,
    ?matchFilters: obj
    ): unit -> bool

let useParams(): obj

let useBeforeLeave(listener: BeforeLeaveEventArgs -> unit): unit

type BeforeLeaveEventArgs = interface

member from: Location

member ``to``: U2<string, float>

member options: NavigateOptions option

member defaultPrevented: bool

member preventDefault: unit -> unit

member retry: ?force: bool -> unit

let useCurrentMatches(): unit -> RouteMatch[]

type RouteMatch = inherit PathMatch

member route: RouteDescription

type PathMatch = interface

member ``params``: obj

member path: string

type RouteDescription = interface

member key: obj

member originalPath: string

member pattern: string

member preload: RoutePreloadFunc option

member matcher: string -> PathMatch option

member matchFilters: obj option

member info: obj option

let usePreloadRoute(): (string -> PreloadData) -> unit

let useSearchParams(): Signal<obj>