export declare const Do: {}

export declare const andThenBind: {
  <N extends string, A extends object, B>(name: Exclude<N, keyof A>, that: B): (self: A) => {
    [K in N | keyof A]: K extends keyof A ? A[K] : B
  }
  <A extends object, N extends string, B>(self: A, name: Exclude<N, keyof A>, that: B): {
    [K in N | keyof A]: K extends keyof A ? A[K] : B
  }
}

export declare const bind: {
  <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (a: A) => B): (self: A) => {
    [K in N | keyof A]: K extends keyof A ? A[K] : B
  }
  <A extends object, N extends string, B>(self: A, name: Exclude<N, keyof A>, f: (a: A) => B): {
    [K in N | keyof A]: K extends keyof A ? A[K] : B
  }
}

export declare const bindTo: {
  <N extends string>(name: N): <A>(self: A) => { [K in N]: A }
  <A, N extends string>(self: A, name: N): { [K in N]: A }
}

export declare const let: {
  <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (a: A) => B): (self: A) => {
    [K in N | keyof A]: K extends keyof A ? A[K] : B
  }
  <A extends object, N extends string, B>(self: A, name: Exclude<N, keyof A>, f: (a: A) => B): {
    [K in N | keyof A]: K extends keyof A ? A[K] : B
  }
}

export declare const Applicative: applicative.Applicative<IdentityTypeLambda>

export declare const Chainable: chainable.Chainable<IdentityTypeLambda>

export declare const Covariant: covariant.Covariant<IdentityTypeLambda>

export declare const FlatMap: flatMap_.FlatMap<IdentityTypeLambda>

export declare const Foldable: foldable.Foldable<IdentityTypeLambda>

export declare const Invariant: invariant.Invariant<IdentityTypeLambda>

export declare const Monad: monad.Monad<IdentityTypeLambda>

export declare const Of: of_.Of<IdentityTypeLambda>

export declare const Pointed: pointed.Pointed<IdentityTypeLambda>

export declare const Product: product_.Product<IdentityTypeLambda>

export declare const SemiApplicative: semiApplicative.SemiApplicative<IdentityTypeLambda>

export declare const SemiProduct: semiProduct.SemiProduct<IdentityTypeLambda>

export declare const Traversable: traversable.Traversable<IdentityTypeLambda>

export declare const getSemiAlternative: <A>(
  S: Semigroup<A>
) => semiAlternative.SemiAlternative<IdentityTypeLambdaFix<A>>

export declare const getSemiCoproduct: <A>(S: Semigroup<A>) => semiCoproduct.SemiCoproduct<IdentityTypeLambdaFix<A>>

export type Identity<A> = A

export interface IdentityTypeLambda extends TypeLambda {
  readonly type: Identity<this['Target']>
}

export interface IdentityTypeLambdaFix<A> extends TypeLambda {
  readonly type: Identity<A>
}