export declare const append: {
  (key: string, value: Coercible): (self: UrlParams) => UrlParams
  (self: UrlParams, key: string, value: Coercible): UrlParams
}

export declare const appendAll: {
  (input: Input): (self: UrlParams) => UrlParams
  (self: UrlParams, input: Input): UrlParams
}

export declare const getAll: {
  (key: string): (self: UrlParams) => ReadonlyArray<string>
  (self: UrlParams, key: string): ReadonlyArray<string>
}

export declare const getFirst: {
  (key: string): (self: UrlParams) => Option.Option<string>
  (self: UrlParams, key: string): Option.Option<string>
}

export declare const getLast: {
  (key: string): (self: UrlParams) => Option.Option<string>
  (self: UrlParams, key: string): Option.Option<string>
}

export declare const remove: {
  (key: string): (self: UrlParams) => UrlParams
  (self: UrlParams, key: string): UrlParams
}

export declare const set: {
  (key: string, value: Coercible): (self: UrlParams) => UrlParams
  (self: UrlParams, key: string, value: Coercible): UrlParams
}

export declare const setAll: {
  (input: Input): (self: UrlParams) => UrlParams
  (self: UrlParams, input: Input): UrlParams
}

export declare const empty: UrlParams

export declare const fromInput: (input: Input) => UrlParams

export declare const makeUrl: (url: string, params: UrlParams, hash: Option.Option<string>) => Either.Either<URL, Error>

export declare const toRecord: (self: UrlParams) => Record<string, string | Arr.NonEmptyArray<string>>

import { UrlParams } from "@effect/platform"

const urlParams = UrlParams.fromInput({ a: 1, b: true, c: "string", e: [1, 2, 3] })
const result = UrlParams.toRecord(urlParams)

assert.deepStrictEqual(result, { a: "1", b: "true", c: "string", e: ["1", "2", "3"] })

export declare const toString: (self: UrlParams) => string

export type Coercible = string | number | bigint | boolean | null | undefined

export type Input =
  | Readonly<Record<string, Coercible | ReadonlyArray<Coercible>>>
  | Iterable<readonly [string, Coercible]>
  | URLSearchParams

export interface UrlParams extends ReadonlyArray<readonly [string, string]> {}

export declare const schemaJson: <A, I, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => {
  (field: string): (self: UrlParams) => Effect.Effect<A, ParseResult.ParseError, R>
  (self: UrlParams, field: string): Effect.Effect<A, ParseResult.ParseError, R>
}

export declare const schemaStruct: <A, I extends Record<string, string | ReadonlyArray<string> | undefined>, R>(
  schema: Schema.Schema<A, I, R>,
  options?: ParseOptions | undefined
) => (self: UrlParams) => Effect.Effect<A, ParseResult.ParseError, R>

import { Effect, Schema } from "effect"
import { UrlParams } from "@effect/platform"

Effect.gen(function* () {
  const urlParams = UrlParams.fromInput({ a: [10, "string"], b: false })
  const result = yield* UrlParams.schemaStruct(
    Schema.Struct({
      a: Schema.Tuple(Schema.NumberFromString, Schema.String),
      b: Schema.BooleanFromString
    })
  )(urlParams)

  assert.deepStrictEqual(result, {
    a: [10, "string"],
    b: false
  })
})

export declare const schema: Schema.Schema<UrlParams, readonly (readonly [string, string])[]>