SemiProduct

declare function productMany<F extends TypeLambda>(
  map: {
    <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>;
    <R, O, E, A, B>(self: Kind<F, R, O, E, A>, f: (a: A) => B): Kind<F, R, O, E, B>;
  },
  product: <R1, O1, E1, A, R2, O2, E2, B>(
    self: Kind<F, R1, O1, E1, A>,
    that: Kind<F, R2, O2, E2, B>,
  ) => Kind<F, R1 & R2, O1 | O2, E1 | E2, [A, B]>,
): <R, O, E, A>(
  self: Kind<F, R, O, E, A>,
  collection: Iterable<Kind<F, R, O, E, A>>,
) => Kind<F, R, O, E, [A, ...Array<A>]>;

declare function andThenBind<F extends TypeLambda>(
  F: SemiProduct<F>,
): {
  <N extends string, A extends object, R2, O2, E2, B>(
    name: Exclude<N, keyof A>,
    that: Kind<F, R2, O2, E2, B>,
  ): <R1, O1, E1>(
    self: Kind<F, R1, O1, E1, A>,
  ) => Kind<
    F,
    R1 & R2,
    O2 | O1,
    E2 | E1,
    { [K in string | number | symbol]: K extends keyof A ? A[K] : B }
  >;
  <R1, O1, E1, A extends object, N extends string, R2, O2, E2, B>(
    self: Kind<F, R1, O1, E1, A>,
    name: Exclude<N, keyof A>,
    that: Kind<F, R2, O2, E2, B>,
  ): Kind<
    F,
    R1 & R2,
    O1 | O2,
    E1 | E2,
    { [K in string | number | symbol]: K extends keyof A ? A[K] : B }
  >;
};

declare function appendElement<F extends TypeLambda>(F: SemiProduct<F>): {
  <R2, O2, E2, B>(that: Kind<F, R2, O2, E2, B>): <R1, O1, E1, A extends readonly Array<any>>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, [...Array<A>, B]>;
  <R1, O1, E1, A extends readonly Array<any>, R2, O2, E2, B>(self: Kind<F, R1, O1, E1, A>, that: Kind<F, R2, O2, E2, B>): Kind<F, R1 & R2, O1 | O2, E1 | E2, [...Array<A>, B]>;
}

declare function nonEmptyStruct<F extends TypeLambda>(
  F: SemiProduct<F>,
): <
  R extends {
    [x: string]: Kind<F, any, any, any, any>;
  },
>(
  fields: EnforceNonEmptyRecord<R> & {
    [x: string]: Kind<F, any, any, any, any>;
  },
) => Kind<
  F,
  [R[keyof R]] extends [Kind<F, R, any, any, any>] ? R : never,
  [R[keyof R]] extends [Kind<F, any, O, any, any>] ? O : never,
  [R[keyof R]] extends [Kind<F, any, any, E, any>] ? E : never,
  { [K in string | number | symbol]: [R[K]] extends [Kind<F, any, any, any, A>] ? A : never }
>;

declare function nonEmptyTuple<F extends TypeLambda>(
  F: SemiProduct<F>,
): <T extends readonly [Kind<F, any, any, any, any>, Kind<F, any, any, any, any>]>(
  ...elements: T
) => Kind<
  F,
  [T[number]] extends [Kind<F, R, any, any, any>] ? R : never,
  [T[number]] extends [Kind<F, any, O, any, any>] ? O : never,
  [T[number]] extends [Kind<F, any, any, E, any>] ? E : never,
  { [I in string | number | symbol]: [T[I]] extends [Kind<F, any, any, any, A>] ? A : never }
>;

declare function productComposition<F extends TypeLambda, G extends TypeLambda>(
  F: SemiApplicative<F>,
  G: SemiProduct<G>,
): <FR1, FO1, FE1, GR1, GO1, GE1, A, FR2, FO2, FE2, GR2, GO2, GE2, B>(
  self: Kind<F, FR1, FO1, FE1, Kind<G, GR1, GO1, GE1, A>>,
  that: Kind<F, FR2, FO2, FE2, Kind<G, GR2, GO2, GE2, B>>,
) => Kind<F, FR1 & FR2, FO1 | FO2, FE1 | FE2, Kind<G, GR1 & GR2, GO1 | GO2, GE1 | GE2, [A, B]>>;

declare function productManyComposition<F extends TypeLambda, G extends TypeLambda>(
  F: SemiApplicative<F>,
  G: SemiProduct<G>,
): <FR, FO, FE, GR, GO, GE, A>(
  self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>,
  collection: Iterable<Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>>,
) => Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, [A, ...Array<A>]>>;

interface SemiProduct<F extends TypeLambda> extends Invariant<F> {
  readonly product: <R1, O1, E1, A, R2, O2, E2, B>(
    self: Kind<F, R1, O1, E1, A>,
    that: Kind<F, R2, O2, E2, B>,
  ) => Kind<F, R1 & R2, O1 | O2, E1 | E2, [A, B]>;
  readonly productMany: <R, O, E, A>(
    self: Kind<F, R, O, E, A>,
    collection: Iterable<Kind<F, R, O, E, A>>,
  ) => Kind<F, R, O, E, [A, ...Array<A>]>;
}