SortedSet

declare function empty<A>(O: Order<A>): SortedSet<A>;

declare const fromIterable: {
  <B>(ord: Order<B>): <A>(iterable: Iterable<A>) => SortedSet<A>;
  <A, B>(iterable: Iterable<A>, ord: Order<B>): SortedSet<A>;
};

declare function make<K>(ord: Order<K>): <Entries extends readonly Array<K>>(...entries: Entries) => SortedSet<Entries[number]>

declare const add: {
  <A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
  <A>(self: SortedSet<A>, value: A): SortedSet<A>;
};

declare const every: {
  <A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean;
  <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean;
};

declare const has: {
  <A>(value: A): (self: SortedSet<A>) => boolean;
  <A>(self: SortedSet<A>, value: A): boolean;
};

declare const isSubset: {
  <A>(that: SortedSet<A>): (self: SortedSet<A>) => boolean;
  <A>(self: SortedSet<A>, that: SortedSet<A>): boolean;
};

declare const remove: {
  <A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
  <A>(self: SortedSet<A>, value: A): SortedSet<A>;
};

declare const some: {
  <A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean;
  <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean;
};

declare const toggle: {
  <A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
  <A>(self: SortedSet<A>, value: A): SortedSet<A>;
};

declare function getEquivalence<A>(): Equivalence<SortedSet<A>>;

declare const filter: {
  <A, B>(predicate: Predicate<B>): (self: SortedSet<A>) => SortedSet<A>;
  <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>;
};

declare const partition: {
  <A>(
    predicate: (a: NoInfer<A>) => boolean,
  ): (self: SortedSet<A>) => [excluded: SortedSet<A>, satisfying: SortedSet<A>];
  <A>(
    self: SortedSet<A>,
    predicate: (a: A) => boolean,
  ): [excluded: SortedSet<A>, satisfying: SortedSet<A>];
};

declare function size<A>(self: SortedSet<A>): number;

declare function values<A>(self: SortedSet<A>): IterableIterator<A>;

declare const map: {
  <B, A>(O: Order<B>, f: (a: A) => B): (self: SortedSet<A>) => SortedSet<B>;
  <B, A>(self: SortedSet<A>, O: Order<B>, f: (a: A) => B): SortedSet<B>;
};

interface SortedSet<in out A> extends Iterable<A>, Equal, Pipeable, Inspectable {
  readonly [TypeId]: {
    readonly _A: Invariant<A>;
  };
}

declare const difference: {
  <A, B>(that: Iterable<B>): (self: SortedSet<A>) => SortedSet<A>;
  <A, B>(self: SortedSet<A>, that: Iterable<B>): SortedSet<A>;
};

declare const intersection: {
  <A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>;
  <A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>;
};

declare const union: {
  <A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>;
  <A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>;
};

declare const isSortedSet: {
  <A>(u: Iterable<A>): u is SortedSet<A>;
  (u: unknown): u is SortedSet<unknown>;
};

declare const flatMap: {
  <B, A>(O: Order<B>, f: (a: A) => Iterable<B>): (self: SortedSet<A>) => SortedSet<B>;
  <A, B>(self: SortedSet<A>, O: Order<B>, f: (a: A) => Iterable<B>): SortedSet<B>;
};

type TypeId = typeof TypeId;

declare const forEach: {
  <A>(f: (a: A) => void): (self: SortedSet<A>) => void;
  <A>(self: SortedSet<A>, f: (a: A) => void): void;
};