export declare const empty: <A>(O: Order<A>) => SortedSet<A>

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

export declare const make: <K>(
  ord: Order<K>
) => <Entries extends ReadonlyArray<K>>(...entries: Entries) => SortedSet<Entries[number]>

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

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

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

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

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

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

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

export declare const getEquivalence: <A>() => Equivalence.Equivalence<SortedSet<A>>

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

export 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>]
}

export declare const size: <A>(self: SortedSet<A>) => number

export declare const values: <A>(self: SortedSet<A>) => IterableIterator<A>

export 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>
}

export interface SortedSet<in out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
  readonly [TypeId]: {
    readonly _A: Invariant<A>
  }
  /** @internal */
  readonly keyTree: RBT.RedBlackTree<A, boolean>
}

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

export 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>
}

export type TypeId = typeof TypeId

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

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

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

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