utils

export declare const BeforeNavigationEvent: Schema.Struct<{
  type: Schema.Literal<["push", "replace", "reload", "traverse"]>
  from: Schema.Struct<{
    id: Schema.Schema<Uuid, string, never>
    key: Schema.Schema<Uuid, string, never>
    url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>
    state: typeof Schema.Unknown
    sameDocument: typeof Schema.Boolean
  }>
  delta: typeof Schema.Number
  to: Schema.Union<
    [
      Schema.SchemaClass<
        { readonly url: URL; readonly state: unknown; readonly sameDocument: boolean },
        { readonly url: string; readonly state: unknown; readonly sameDocument: boolean },
        never
      >,
      Schema.Struct<{
        id: Schema.Schema<Uuid, string, never>
        key: Schema.Schema<Uuid, string, never>
        url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>
        state: typeof Schema.Unknown
        sameDocument: typeof Schema.Boolean
      }>
    ]
  >
  info: typeof Schema.Unknown
}>

export interface BeforeNavigationEvent extends Schema.Schema.Type<typeof BeforeNavigationEvent> {}

export type BeforeNavigationEventJson = Schema.Schema.Encoded<typeof BeforeNavigationEvent>

export type BeforeNavigationHandler<R, R2> = (
  event: BeforeNavigationEvent
) => Effect.Effect<
  Option.Option<Effect.Effect<unknown, RedirectError | CancelNavigation, R2>>,
  RedirectError | CancelNavigation,
  R
>

export declare const CanGoBack: RefSubject.Computed<boolean, never, Navigation>

export declare const CanGoForward: RefSubject.Computed<boolean, never, Navigation>

export declare class CancelNavigation

export declare const CurrentEntries: RefSubject.Computed<readonly Destination[], never, Navigation>

export declare const CurrentEntry: RefSubject.Computed<Destination, never, Navigation>

export declare const CurrentPath: RefSubject.Computed<string, never, Navigation>

export declare const Destination: Schema.Struct<{
  id: Schema.Schema<Uuid, string, never>
  key: Schema.Schema<Uuid, string, never>
  url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>
  state: typeof Schema.Unknown
  sameDocument: typeof Schema.Boolean
}>

export interface Destination extends Schema.Schema.Type<typeof Destination> {}

export type DestinationJson = Schema.Schema.Encoded<typeof Destination>

export declare const FileSchema: Schema.transformOrFail<
  Schema.Struct<{ _id: Schema.Literal<["File"]>; name: typeof Schema.String; data: typeof Schema.String }>,
  Schema.instanceOf<File>,
  never
>

export declare const FileSchemaFrom: Schema.Struct<{
  _id: Schema.Literal<["File"]>
  name: typeof Schema.String
  data: typeof Schema.String
}>

export type FileSchemaFrom = Schema.Schema.Encoded<typeof FileSchemaFrom>

export declare const FormDataEvent: Schema.extend<
  Schema.Struct<{
    from: Schema.Struct<{
      id: Schema.Schema<Uuid, string, never>
      key: Schema.Schema<Uuid, string, never>
      url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>
      state: typeof Schema.Unknown
      sameDocument: typeof Schema.Boolean
    }>
  }>,
  Schema.Struct<{
    name: Schema.optionalWith<typeof Schema.String, { readonly as: "Option"; readonly nullable: true }>
    action: Schema.optionalWith<typeof Schema.String, { readonly as: "Option"; readonly nullable: true }>
    method: Schema.optionalWith<typeof Schema.String, { readonly as: "Option"; readonly nullable: true }>
    encoding: Schema.optionalWith<typeof Schema.String, { readonly as: "Option"; readonly nullable: true }>
    data: Schema.transform<
      Schema.Record$<
        typeof Schema.String,
        Schema.Union<
          [
            typeof Schema.String,
            Schema.transformOrFail<
              Schema.Struct<{ _id: Schema.Literal<["File"]>; name: typeof Schema.String; data: typeof Schema.String }>,
              Schema.instanceOf<File>,
              never
            >
          ]
        >
      >,
      Schema.instanceOf<FormData>
    >
  }>
>

export interface FormDataEvent extends Schema.Schema.Type<typeof FormDataEvent> {}

export type FormDataEventJson = Schema.Schema.Encoded<typeof FormDataEvent>

export type FormDataHandler<R, R2> = (
  event: FormDataEvent
) => Effect.Effect<
  Option.Option<
    Effect.Effect<Option.Option<HttpClientResponse.HttpClientResponse>, RedirectError | CancelNavigation, R2>
  >,
  RedirectError | CancelNavigation,
  R
>

export declare const FormDataSchema: Schema.transform<
  Schema.Record$<
    typeof Schema.String,
    Schema.Union<
      [
        typeof Schema.String,
        Schema.transformOrFail<
          Schema.Struct<{ _id: Schema.Literal<["File"]>; name: typeof Schema.String; data: typeof Schema.String }>,
          Schema.instanceOf<File>,
          never
        >
      ]
    >
  >,
  Schema.instanceOf<FormData>
>

export interface FormInput extends Schema.Schema.Type<typeof FormInputSchema> {}

export type FormInputFrom = Schema.Schema.Encoded<typeof FormInputSchema>

export declare const FormInputSchema: Schema.Struct<{
  name: Schema.optionalWith<typeof Schema.String, { readonly as: "Option"; readonly nullable: true }>
  action: Schema.optionalWith<typeof Schema.String, { readonly as: "Option"; readonly nullable: true }>
  method: Schema.optionalWith<typeof Schema.String, { readonly as: "Option"; readonly nullable: true }>
  encoding: Schema.optionalWith<typeof Schema.String, { readonly as: "Option"; readonly nullable: true }>
  data: Schema.transform<
    Schema.Record$<
      typeof Schema.String,
      Schema.Union<
        [
          typeof Schema.String,
          Schema.transformOrFail<
            Schema.Struct<{ _id: Schema.Literal<["File"]>; name: typeof Schema.String; data: typeof Schema.String }>,
            Schema.instanceOf<File>,
            never
          >
        ]
      >
    >,
    Schema.instanceOf<FormData>
  >
}>

export interface NavigateOptions {
  readonly history?: "replace" | "push" | "auto"
  readonly state?: unknown
  readonly info?: unknown
}

export declare const Navigation: Tagged<Navigation, Navigation>

export interface Navigation {
  readonly origin: string

  readonly base: string

  readonly currentEntry: RefSubject.Computed<Destination>

  readonly entries: RefSubject.Computed<ReadonlyArray<Destination>>

  readonly transition: RefSubject.Computed<Option.Option<Transition>>

  readonly canGoBack: RefSubject.Computed<boolean>

  readonly canGoForward: RefSubject.Computed<boolean>

  readonly navigate: (url: string | URL, options?: NavigateOptions) => Effect.Effect<Destination, NavigationError>

  readonly back: (options?: { readonly info?: unknown }) => Effect.Effect<Destination, NavigationError>

  readonly forward: (options?: { readonly info?: unknown }) => Effect.Effect<Destination, NavigationError>

  readonly traverseTo: (
    key: Destination["key"],
    options?: { readonly info?: unknown }
  ) => Effect.Effect<Destination, NavigationError>

  readonly updateCurrentEntry: (options: { readonly state: unknown }) => Effect.Effect<Destination, NavigationError>

  readonly reload: (options?: {
    readonly info?: unknown
    readonly state?: unknown
  }) => Effect.Effect<Destination, NavigationError>

  readonly beforeNavigation: <R = never, R2 = never>(
    handler: BeforeNavigationHandler<R, R2>
  ) => Effect.Effect<void, never, R | R2 | Scope.Scope>

  readonly onNavigation: <R = never, R2 = never>(
    handler: NavigationHandler<R, R2>
  ) => Effect.Effect<void, never, R | R2 | Scope.Scope>

  readonly submit: (
    data: FormData,
    formInput?: Simplify<Omit<FormInputFrom, "data">>
  ) => Effect.Effect<
    Option.Option<HttpClientResponse.HttpClientResponse>,
    NavigationError | HttpClientError.HttpClientError,
    Scope.Scope | HttpClient.HttpClient.Service
  >

  readonly onFormData: <R = never, R2 = never>(
    handler: FormDataHandler<R, R2>
  ) => Effect.Effect<void, never, R | R2 | Scope.Scope>
}

export declare class NavigationError

export declare const NavigationEvent: Schema.Struct<{
  type: Schema.Literal<["push", "replace", "reload", "traverse"]>
  destination: Schema.Struct<{
    id: Schema.Schema<Uuid, string, never>
    key: Schema.Schema<Uuid, string, never>
    url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>
    state: typeof Schema.Unknown
    sameDocument: typeof Schema.Boolean
  }>
  info: typeof Schema.Unknown
}>

export interface NavigationEvent extends Schema.Schema.Type<typeof NavigationEvent> {}

export type NavigationEventJson = Schema.Schema.Encoded<typeof NavigationEvent>

export type NavigationHandler<R, R2> = (
  event: NavigationEvent
) => Effect.Effect<Option.Option<Effect.Effect<unknown, never, R2>>, never, R>

export declare const NavigationType: Schema.Literal<["push", "replace", "reload", "traverse"]>

export type NavigationType = Schema.Schema.Type<typeof NavigationType>

export declare const ProposedDestination: Schema.SchemaClass<
  { readonly url: URL; readonly state: unknown; readonly sameDocument: boolean },
  { readonly url: string; readonly state: unknown; readonly sameDocument: boolean },
  never
>

export interface ProposedDestination extends Schema.Schema.Type<typeof ProposedDestination> {}

export type ProposedDestinationJson = Schema.Schema.Encoded<typeof ProposedDestination>

export declare class RedirectError

export declare const Transition: Schema.Struct<{
  type: Schema.Literal<["push", "replace", "reload", "traverse"]>
  from: Schema.Struct<{
    id: Schema.Schema<Uuid, string, never>
    key: Schema.Schema<Uuid, string, never>
    url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>
    state: typeof Schema.Unknown
    sameDocument: typeof Schema.Boolean
  }>
  to: Schema.Union<
    [
      Schema.SchemaClass<
        { readonly url: URL; readonly state: unknown; readonly sameDocument: boolean },
        { readonly url: string; readonly state: unknown; readonly sameDocument: boolean },
        never
      >,
      Schema.Struct<{
        id: Schema.Schema<Uuid, string, never>
        key: Schema.Schema<Uuid, string, never>
        url: Schema.transformOrFail<typeof Schema.String, Schema.Schema<URL, URL, never>, never>
        state: typeof Schema.Unknown
        sameDocument: typeof Schema.Boolean
      }>
    ]
  >
}>

export interface Transition extends Schema.Schema.Type<typeof Transition> {}

export type TransitionJson = Schema.Schema.Encoded<typeof Transition>

export declare const back: (options?: {
  readonly info?: unknown
}) => Effect.Effect<Destination, NavigationError, Navigation>

export declare const cancelNavigation: CancelNavigation

export declare const forward: (options?: {
  readonly info?: unknown
}) => Effect.Effect<Destination, NavigationError, Navigation>

export declare function getCurrentPathFromUrl(location: Pick<URL, "pathname" | "search" | "hash">): string

export declare function handleRedirect(error: RedirectError)

export declare function isCancelNavigation(e: unknown): e is CancelNavigation

export declare function isNavigationError(e: unknown): e is NavigationError

export declare function isRedirectError(e: unknown): e is RedirectError

export declare const navigate: (
  url: string | URL,
  options?: NavigateOptions
) => Effect.Effect<Destination, NavigationError, Navigation>

export declare function onFormData<R = never, R2 = never>(
  handler: FormDataHandler<R, R2>
): Effect.Effect<void, never, Navigation | R | R2 | Scope.Scope>

export declare function redirectToPath(
  path: string | URL,
  options?: { readonly state?: unknown; readonly info?: unknown }
): RedirectError

export declare const reload: (options?: {
  readonly info?: unknown
  readonly state?: unknown
}) => Effect.Effect<Destination, NavigationError, Navigation>

export declare function submit(
  data: FormData,
  formInput?: Simplify<Omit<FormInputFrom, "data">>
): Effect.Effect<
  Option.Option<HttpClientResponse.HttpClientResponse>,
  NavigationError | HttpClientError.HttpClientError,
  Navigation | HttpClient.HttpClient.Service | Scope.Scope
>

export declare const traverseTo: (
  key: Uuid,
  options?: { readonly info?: unknown }
) => Effect.Effect<Destination, NavigationError, Navigation>

export declare const updateCurrentEntry: (options: {
  readonly state: unknown
}) => Effect.Effect<Destination, NavigationError, Navigation>