import { Collection } from "@tsplus/stdlib/collections/Collection/definition";
import { Equals } from "@tsplus/stdlib/structure/Equals";
import { Hash } from "@tsplus/stdlib/structure/Hash";
export declare const ListTypeId: unique symbol;
export type ListTypeId = typeof ListTypeId;
export declare const _A: unique symbol;
export type _A = typeof _A;
/**
 * @tsplus type List
 */
export type List<A> = Cons<A> | Nil<A>;
type ConsNS<A> = Cons<A>;
type NilNS<A> = Nil<A>;
export declare namespace List {
    type Cons<A> = ConsNS<A>;
    type Nil<A> = NilNS<A>;
}
/**
 * @tsplus type List.Ops
 */
export interface ListOps {
    readonly $: ListAspects;
}
export declare const List: ListOps;
/**
 * @tsplus type List.Aspects
 */
export interface ListAspects {
}
export declare namespace List {
    /**
     * @tsplus type NonEmptyList
     */
    type NonEmpty<A> = Cons<A>;
}
/**
 * @tsplus type List/Cons
 */
export declare class Cons<A> implements Collection<A>, Equals {
    readonly head: A;
    tail: List<A>;
    readonly _tag = "Cons";
    readonly [_A]: (_: never) => A;
    readonly [ListTypeId]: symbol;
    constructor(head: A, tail: List<A>);
    [Symbol.iterator](): Iterator<A>;
    [Hash.sym](): number;
    [Equals.sym](that: unknown): boolean;
}
/**
 * @tsplus type List/Nil
 */
export declare class Nil<A> implements Collection<A>, Equals {
    readonly _tag = "Nil";
    readonly [_A]: (_: never) => A;
    readonly [ListTypeId]: symbol;
    [Symbol.iterator](): Iterator<A>;
    [Hash.sym](): number;
    [Equals.sym](that: unknown): boolean;
}
export declare const _Nil: Nil<never>;
/**
 * @tsplus unify List
 * @tsplus unify List/Nil
 * @tsplus unify List/Cons
 */
export declare function unify<X extends List<any>>(self: X): List<[X] extends [{
    readonly [_A]: (_: never) => infer A;
}] ? A : never>;
/**
 * @tsplus static List.Ops nil
 * @tsplus location "@tsplus/stdlib/collections/List/definition"
 */
export declare function nil<A = never>(): Nil<A>;
/**
 * @tsplus static List.Ops cons
 * @tsplus location "@tsplus/stdlib/collections/List/definition"
 */
export declare function cons<A>(head: A, tail: List<A>): Cons<A>;
/**
 * @tsplus fluent List isNil
 * @tsplus location "@tsplus/stdlib/collections/List/definition"
 */
export declare function isNil<A>(self: List<A>): self is Nil<A>;
/**
 * @tsplus fluent List isCons
 * @tsplus location "@tsplus/stdlib/collections/List/definition"
 */
export declare function isCons<A>(self: List<A>): self is Cons<A>;
/**
 * Returns the number of elements contained in a `List`
 * @tsplus getter List length
 * @tsplus location "@tsplus/stdlib/collections/List/definition"
 */
export declare function length<A>(self: List<A>): number;
/**
 * @tsplus static List.Aspects equalsWith
 * @tsplus pipeable List equalsWith
 * @tsplus location "@tsplus/stdlib/collections/List/definition"
 */
export declare function equalsWith<A, B>(that: List<B>, f: (a: A, b: B) => boolean): (self: List<A>) => boolean;
/**
 * @tsplus pipeable-operator List ==
 * @tsplus static List.Aspects equals
 * @tsplus pipeable List equals
 * @tsplus location "@tsplus/stdlib/collections/List/definition"
 */
export declare function equals<A>(that: List<A>): (self: List<A>) => boolean;
export declare function equals<B>(that: List<B>): <A>(self: List<A>) => boolean;
/**
 * Type guard
 * @tsplus static List.Ops isList
 * @tsplus location "@tsplus/stdlib/collections/List/definition"
 */
export declare function isList<A>(u: Iterable<A>): u is List<A>;
export declare function isList(u: unknown): u is List<unknown>;
export {};
//# sourceMappingURL=definition.d.ts.map