SortedMap

declare function empty<K, V = never>(ord: Order<K>): SortedMap<K, V>;

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

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

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

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

declare function headOption<K, V>(self: SortedMap<K, V>): Option<[K, V]>;

declare function lastOption<K, V>(self: SortedMap<K, V>): Option<[K, V]>;

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

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

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

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

declare function entries<K, V>(self: SortedMap<K, V>): IterableIterator<[K, V]>;

declare function getOrder<K, V>(self: SortedMap<K, V>): Order<K>;

declare function keys<K, V>(self: SortedMap<K, V>): IterableIterator<K>;

declare function size<K, V>(self: SortedMap<K, V>): number;

declare function values<K, V>(self: SortedMap<K, V>): IterableIterator<V>;

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

interface SortedMap<in out K, out V> extends Iterable<[K, V]>, Equal, Pipeable, Inspectable {
  readonly [TypeId]: {
    readonly _K: Invariant<K>;
    readonly _V: Covariant<V>;
  };
}

declare function isEmpty<K, V>(self: SortedMap<K, V>): boolean;

declare function isNonEmpty<K, V>(self: SortedMap<K, V>): boolean;

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

type TypeId = typeof TypeId;