declare const compile: <
  I extends Record<string, Parameter.Parameter<any>>,
  O extends Record<string, Parameter.Parameter<any>>,
  A
>(
  self: Procedure<I, O, A>
) => (input: Procedure.ParametersRecord<I>) => ProcedureWithValues<I, O, A>

declare const outputParam: <A>() => <N extends string, T extends DataType>(
  name: N,
  type: T,
  options?: ParameterOptions
) => <I extends Record<string, Parameter.Parameter<any>>, O extends Record<string, Parameter.Parameter<any>>>(
  self: Procedure<I, O>
) => Procedure<I, Simplify<O & { [K in N]: Parameter.Parameter<A> }>>

declare const param: <A>() => <N extends string, T extends DataType>(
  name: N,
  type: T,
  options?: ParameterOptions
) => <I extends Record<string, Parameter.Parameter<any>>, O extends Record<string, Parameter.Parameter<any>>>(
  self: Procedure<I, O>
) => Procedure<Simplify<I & { [K in N]: Parameter.Parameter<A> }>, O>

declare const withRows: <A extends object = Row>() => <
  I extends Record<string, Parameter.Parameter<any>>,
  O extends Record<string, Parameter.Parameter<any>>
>(
  self: Procedure<I, O>
) => Procedure<I, O, A>

declare const make: (name: string) => Procedure<{}, {}>

export interface Procedure<
  I extends Record<string, Parameter.Parameter<any>>,
  O extends Record<string, Parameter.Parameter<any>>,
  A = never
> extends Pipeable {
  readonly [TypeId]: {
    readonly _A: Covariant<A>
  }
  readonly _tag: "Procedure"
  readonly name: string
  readonly params: I
  readonly outputParams: O
}

export interface ProcedureWithValues<
  I extends Record<string, Parameter.Parameter<any>>,
  O extends Record<string, Parameter.Parameter<any>>,
  A
> extends Procedure<I, O, A> {
  readonly values: Procedure.ParametersRecord<I>
}

declare const TypeId: unique symbol

type TypeId = typeof TypeId

export interface Result<O extends Record<string, Parameter.Parameter<any>>, A> {
  readonly output: ParametersRecord<O>
  readonly rows: ReadonlyArray<A>
}

type { readonly [K in keyof A]: A[K] extends Parameter.Parameter<infer T> ? T : never; } = & {
      readonly [K in keyof A]: A[K] extends Parameter.Parameter<infer T> ? T
        : never
    }
    & {}