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

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

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

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

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

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

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

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

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

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

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

export declare const CounterStateTypeId: typeof CounterStateTypeId

export type CounterStateTypeId = typeof CounterStateTypeId

export declare const FrequencyStateTypeId: typeof FrequencyStateTypeId

export type FrequencyStateTypeId = typeof FrequencyStateTypeId

export declare const GaugeStateTypeId: typeof GaugeStateTypeId

export type GaugeStateTypeId = typeof GaugeStateTypeId

export declare const HistogramStateTypeId: typeof HistogramStateTypeId

export type HistogramStateTypeId = typeof HistogramStateTypeId

export declare const MetricStateTypeId: typeof MetricStateTypeId

export type MetricStateTypeId = typeof MetricStateTypeId

export declare const SummaryStateTypeId: typeof SummaryStateTypeId

export type SummaryStateTypeId = typeof SummaryStateTypeId

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 Untyped extends MetricState<any> {}

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