export declare const empty: <K, V = never>(ord: Order<K>) => SortedMap<K, V>

export declare const fromIterable: {
  <B>(ord: Order<B>): <K extends B, V>(iterable: Iterable<readonly [K, V]>) => SortedMap<K, V>
  <K extends B, V, B>(iterable: Iterable<readonly [K, V]>, ord: Order<B>): SortedMap<K, V>
}

export declare const make: <K>(
  ord: Order<K>
) => <Entries extends readonly (readonly [K, any])[]>(
  ...entries: Entries
) => SortedMap<K, Entries[number] extends readonly [any, infer V] ? V : never>

export declare const get: {
  <K>(key: K): <V>(self: SortedMap<K, V>) => Option.Option<V>
  <K, V>(self: SortedMap<K, V>, key: K): Option.Option<V>
}

export declare const has: {
  <K>(key: K): <V>(self: SortedMap<K, V>) => boolean
  <K, V>(self: SortedMap<K, V>, key: K): boolean
}

export declare const headOption: <K, V>(self: SortedMap<K, V>) => Option.Option<[K, V]>

export declare const remove: {
  <K>(key: K): <V>(self: SortedMap<K, V>) => SortedMap<K, V>
  <K, V>(self: SortedMap<K, V>, key: K): SortedMap<K, V>
}

export declare const set: {
  <K, V>(key: K, value: V): (self: SortedMap<K, V>) => SortedMap<K, V>
  <K, V>(self: SortedMap<K, V>, key: K, value: V): SortedMap<K, V>
}

export declare const reduce: {
  <B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B): (self: SortedMap<K, A>) => B
  <K, A, B>(self: SortedMap<K, A>, zero: B, f: (acc: B, value: A, key: K) => B): B
}

export declare const entries: <K, V>(self: SortedMap<K, V>) => IterableIterator<[K, V]>

export declare const getOrder: <K, V>(self: SortedMap<K, V>) => Order<K>

export declare const keys: <K, V>(self: SortedMap<K, V>) => IterableIterator<K>

export declare const size: <K, V>(self: SortedMap<K, V>) => number

export declare const values: <K, V>(self: SortedMap<K, V>) => IterableIterator<V>

export declare const map: {
  <A, K, B>(f: (a: A, k: K) => B): (self: SortedMap<K, A>) => SortedMap<K, B>
  <K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B): SortedMap<K, B>
}

export interface SortedMap<in out K, out V> extends Iterable<[K, V]>, Equal.Equal, Pipeable, Inspectable {
  readonly [TypeId]: {
    readonly _K: Types.Invariant<K>
    readonly _V: Types.Covariant<V>
  }
  /** @internal */
  readonly tree: RBT.RedBlackTree<K, V>
}

export declare const isEmpty: <K, V>(self: SortedMap<K, V>) => boolean

export declare const isNonEmpty: <K, V>(self: SortedMap<K, V>) => boolean

export declare const isSortedMap: {
  <K, V>(u: Iterable<readonly [K, V]>): u is SortedMap<K, V>
  (u: unknown): u is SortedMap<unknown, unknown>
}

export type TypeId = typeof TypeId