Procedure

declare function compile<
  I extends Record<string, Parameter<any>>,
  O extends Record<string, Parameter<any>>,
  A,
>(
  self: Procedure<I, O, A>,
): (input: {
  [K in string | number | symbol]: I[K] extends Parameter<T> ? T : never;
}) => ProcedureWithValues<I, O, A>;

declare function outputParam<A>(): <N extends string, T extends DataType>(
  name: N,
  type: T,
  options?: any,
) => <I extends Record<string, Parameter<any>>, O extends Record<string, Parameter<any>>>(
  self: Procedure<I, O>,
) => Procedure<I, { [K in string | number | symbol]: O & { [K in string]: Parameter<A> }[K] }>;

declare function param<A>(): <N extends string, T extends DataType>(
  name: N,
  type: T,
  options?: any,
) => <I extends Record<string, Parameter<any>>, O extends Record<string, Parameter<any>>>(
  self: Procedure<I, O>,
) => Procedure<{ [K in string | number | symbol]: I & { [K in string]: Parameter<A> }[K] }, O>;

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

declare function make(name: string): Procedure<{}, {}>;

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

interface ProcedureWithValues<
  I extends Record<string, Parameter.Parameter<any>>,
  O extends Record<string, Parameter.Parameter<any>>,
  A,
> extends Procedure<I, O, A> {
  readonly values: { [K in string | number | symbol]: I[K] extends Parameter<T> ? T : never };
}

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;