declare const counter: { (count: number): MetricState.Counter<number>; (count: bigint): MetricState.Counter<bigint> }

declare const frequency: (occurrences: ReadonlyMap<string, number>) => MetricState.Frequency

declare const gauge: { (count: number): MetricState.Gauge<number>; (count: bigint): MetricState.Gauge<bigint> }

declare const histogram: (options: {
  readonly buckets: ReadonlyArray<readonly [number, number]>
  readonly count: number
  readonly min: number
  readonly max: number
  readonly sum: number
}) => MetricState.Histogram

declare const summary: (options: {
  readonly error: number
  readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>
  readonly count: number
  readonly min: number
  readonly max: number
  readonly sum: number
}) => MetricState.Summary

export interface MetricState<in A> extends MetricState.Variance<A>, Equal.Equal, Pipeable {}

declare const isCounterState: (u: unknown) => u is MetricState.Counter<number | bigint>

declare const isFrequencyState: (u: unknown) => u is MetricState.Frequency

declare const isGaugeState: (u: unknown) => u is MetricState.Gauge<number | bigint>

declare const isHistogramState: (u: unknown) => u is MetricState.Histogram

declare const isMetricState: (u: unknown) => u is MetricState.Counter<number | bigint>

declare const isSummaryState: (u: unknown) => u is MetricState.Summary

declare const CounterStateTypeId: unique symbol

type CounterStateTypeId = typeof CounterStateTypeId

declare const FrequencyStateTypeId: unique symbol

type FrequencyStateTypeId = typeof FrequencyStateTypeId

declare const GaugeStateTypeId: unique symbol

type GaugeStateTypeId = typeof GaugeStateTypeId

declare const HistogramStateTypeId: unique symbol

type HistogramStateTypeId = typeof HistogramStateTypeId

declare const MetricStateTypeId: unique symbol

type MetricStateTypeId = typeof MetricStateTypeId

declare const SummaryStateTypeId: unique symbol

type SummaryStateTypeId = typeof SummaryStateTypeId

export interface Untyped extends MetricState<any> {}

export interface Counter<in out A extends number | bigint> extends MetricState<MetricKeyType.MetricKeyType.Counter<A>> {
  readonly [CounterStateTypeId]: CounterStateTypeId
  readonly count: A
}

export interface Frequency extends MetricState<MetricKeyType.MetricKeyType.Frequency> {
  readonly [FrequencyStateTypeId]: FrequencyStateTypeId
  readonly occurrences: ReadonlyMap<string, number>
}

export interface Gauge<in out A extends number | bigint> extends MetricState<MetricKeyType.MetricKeyType.Gauge<A>> {
  readonly [GaugeStateTypeId]: GaugeStateTypeId
  readonly value: A
}

export interface Histogram extends MetricState<MetricKeyType.MetricKeyType.Histogram> {
  readonly [HistogramStateTypeId]: HistogramStateTypeId
  readonly buckets: ReadonlyArray<readonly [number, number]>
  readonly count: number
  readonly min: number
  readonly max: number
  readonly sum: number
}

export interface Summary extends MetricState<MetricKeyType.MetricKeyType.Summary> {
  readonly [SummaryStateTypeId]: SummaryStateTypeId
  readonly error: number
  readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>
  readonly count: number
  readonly min: number
  readonly max: number
  readonly sum: number
}

export interface Variance<in A> {
  readonly [MetricStateTypeId]: {
    readonly _A: Types.Contravariant<A>
  }
}