export declare class Formatter<A> {
  constructor(readonly run: (r: Route, a: A) => Route)
}

contramap<B>(f: (b: B) => A): Formatter<B>

then<B>(that: Formatter<B> & Formatter<RowLacks<B, keyof A>>): Formatter<A & B>

readonly _A: A

export declare const contramap: <A, B>(f: (b: B) => A) => (fa: Formatter<A>) => Formatter<B>

export declare function format<A>(formatter: Formatter<A>, a: A, encode: boolean = true): string

export declare const formatter: Contravariant1<'fp-ts-routing/Formatter'>

export declare class Match<A> {
  constructor(readonly parser: Parser<A>, readonly formatter: Formatter<A>)
}

imap<B>(f: (a: A) => B, g: (b: B) => A): Match<B>

then<B>(that: Match<B> & Match<RowLacks<B, keyof A>>): Match<A & B>

readonly _A: A

export declare const end: Match<object>

export declare function imap<A, B>(f: (a: A) => B, g: (b: B) => A): (ma: Match<A>) => Match<B>

export declare function int<K extends string>(k: K): Match<{ [_ in K]: number }>

import { int, Route } from '@rjdellecese/fp-ts-routing'
import { some, none } from 'fp-ts/lib/Option'

assert.deepStrictEqual(int('id').parser.run(Route.parse('/1')), some([{ id: 1 }, new Route([], {})]))
assert.deepStrictEqual(int('id').parser.run(Route.parse('/a')), none)

export declare function lit(literal: string): Match<object>

import { lit, Route } from '@rjdellecese/fp-ts-routing'
import { some, none } from 'fp-ts/lib/Option'

assert.deepStrictEqual(lit('subview').parser.run(Route.parse('/subview/')), some([{}, new Route([], {})]))
assert.deepStrictEqual(lit('subview').parser.run(Route.parse('/')), none)

export declare function query<A>(type: Type<A, Record<string, QueryValues>>): Match<A>

import * as t from 'io-ts'
import { lit, str, query, Route } from '@rjdellecese/fp-ts-routing'

const route = lit('accounts')
  .then(str('accountId'))
  .then(lit('files'))
  .then(query(t.strict({ pathparam: t.string })))
  .formatter.run(Route.empty, { accountId: 'testId', pathparam: '123' })
  .toString()
assert.strictEqual(route, '/accounts/testId/files?pathparam=123')

export declare function str<K extends string>(k: K): Match<{ [_ in K]: string }>

import { str, Route } from '@rjdellecese/fp-ts-routing'
import { some, none } from 'fp-ts/lib/Option'

assert.deepStrictEqual(str('id').parser.run(Route.parse('/abc')), some([{ id: 'abc' }, new Route([], {})]))
assert.deepStrictEqual(str('id').parser.run(Route.parse('/')), none)

export declare function succeed<A>(a: A): Match<A>

export declare function then<B>(mb: Match<B>): <A>(ma: Match<A> & Match<RowLacks<A, keyof B>>) => Match<A & B>

export declare function type<K extends string, A>(k: K, type: Type<A, string>): Match<{ [_ in K]: A }>

import * as t from 'io-ts'
import { lit, type, Route } from '@rjdellecese/fp-ts-routing'
import { some, none } from 'fp-ts/lib/Option'

const T = t.keyof({
  a: null,
  b: null,
})

const match = lit('search').then(type('topic', T))

assert.deepStrictEqual(match.parser.run(Route.parse('/search/a')), some([{ topic: 'a' }, Route.empty]))
assert.deepStrictEqual(match.parser.run(Route.parse('/search/b')), some([{ topic: 'b' }, Route.empty]))
assert.deepStrictEqual(match.parser.run(Route.parse('/search/')), none)

export declare class Parser<A> {
  constructor(readonly run: (r: Route) => Option<[A, Route]>)
}

static of<A>(a: A): Parser<A>

map<B>(f: (a: A) => B): Parser<B>

ap<B>(fab: Parser<(a: A) => B>): Parser<B>

chain<B>(f: (a: A) => Parser<B>): Parser<B>

alt(that: Parser<A>): Parser<A>

then<B>(that: Parser<RowLacks<B, keyof A>>): Parser<A & B>

readonly _A: A

export declare const alt: <A>(that: Lazy<Parser<A>>) => (fa: Parser<A>) => Parser<A>

export declare const ap: <A>(fa: Parser<A>) => <B>(fab: Parser<(a: A) => B>) => Parser<B>

export declare const apFirst: <B>(second: Parser<B>) => <A>(first: Parser<A>) => Parser<A>

export declare const apSecond: <B>(second: Parser<B>) => <A>(first: Parser<A>) => Parser<B>

export declare const chain: <A, B>(f: (a: A) => Parser<B>) => (fa: Parser<A>) => Parser<B>

export declare const chainFirst: <A, B>(f: (a: A) => Parser<B>) => (first: Parser<A>) => Parser<A>

export declare const flatten: Monad1<'fp-ts-routing/Parser'> & Alternative1<'fp-ts-routing/Parser'>

export declare const getParserMonoid: <A>() => Monoid<Parser<A>>

export declare const map: <A, B>(f: (a: A) => B) => (fa: Parser<A>) => Parser<B>

export declare function parse<A>(parser: Parser<A>, r: Route, a: A): A

export declare const parser: Monad1<'fp-ts-routing/Parser'> & Alternative1<'fp-ts-routing/Parser'>

export declare function zero<A>(): Parser<A>

export interface Query {
  [key: string]: QueryValues
}

export type QueryValues = string | Array<string> | undefined

export declare class Route {
  constructor(readonly parts: Array<string>, readonly query: Query)
}

static isEmpty(r: Route): boolean

static parse(s: string, decode: boolean = true): Route

toString(encode: boolean = true): string

export type RowLacks<O, K extends string | number | symbol> = O & Record<Extract<keyof O, K>, never>