export declare const compile: <
  I extends Record<string, Parameter.Parameter<any>>,
  O extends Record<string, Parameter.Parameter<any>>,
  A
>(
  self: Procedure<I, O, A>
) => (input: { readonly [K in keyof I]: I[K] extends Parameter.Parameter<infer T> ? T : never }) => ProcedureWithValues<
  I,
  O,
  A
>

export 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, never>
) => Procedure<
  I,
  { [K in keyof (O & { [K in N]: Parameter.Parameter<A> })]: (O & { [K in N]: Parameter.Parameter<A> })[K] },
  never
>

export 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, never>
) => Procedure<
  { [K in keyof (I & { [K in N]: Parameter.Parameter<A> })]: (I & { [K in N]: Parameter.Parameter<A> })[K] },
  O,
  never
>

export 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, never>
) => Procedure<I, O, A>

export 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>
}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

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

export type ParametersRecord<A extends Record<string, Parameter.Parameter<any>>> = {
  readonly [K in keyof A]: A[K] extends Parameter.Parameter<infer T> ? T : never
} & {}