MetricState

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

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

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

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

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

interface MetricState<in A> extends Variance<A>, 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;