declare const counter: <A extends number | bigint>() => MetricKeyType.Counter<A>

declare const frequency: (
  options?: { readonly preregisteredWords?: ReadonlyArray<string> | undefined } | undefined
) => MetricKeyType.Frequency

declare const gauge: <A extends number | bigint>() => MetricKeyType.Gauge<A>

declare const histogram: (boundaries: MetricBoundaries.MetricBoundaries) => MetricKeyType.Histogram

declare const summary: (options: {
  readonly maxAge: Duration.DurationInput
  readonly maxSize: number
  readonly error: number
  readonly quantiles: ReadonlyArray<number>
}) => MetricKeyType.Summary

export interface MetricKeyType<in In, out Out> extends MetricKeyType.Variance<In, Out>, Equal.Equal, Pipeable {}

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

declare const isFrequencyKey: (u: unknown) => u is MetricKeyType.Frequency

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

declare const isHistogramKey: (u: unknown) => u is MetricKeyType.Histogram

declare const isMetricKeyType: (u: unknown) => u is MetricKeyType<unknown, unknown>

declare const isSummaryKey: (u: unknown) => u is MetricKeyType.Summary

declare const CounterKeyTypeTypeId: unique symbol

type CounterKeyTypeTypeId = typeof CounterKeyTypeTypeId

declare const FrequencyKeyTypeTypeId: unique symbol

type FrequencyKeyTypeTypeId = typeof FrequencyKeyTypeTypeId

declare const GaugeKeyTypeTypeId: unique symbol

type GaugeKeyTypeTypeId = typeof GaugeKeyTypeTypeId

declare const HistogramKeyTypeTypeId: unique symbol

type HistogramKeyTypeTypeId = typeof HistogramKeyTypeTypeId

declare const MetricKeyTypeTypeId: unique symbol

type MetricKeyTypeTypeId = typeof MetricKeyTypeTypeId

declare const SummaryKeyTypeTypeId: unique symbol

type SummaryKeyTypeTypeId = typeof SummaryKeyTypeTypeId

export interface Variance<in In, out Out> {
  readonly [MetricKeyTypeTypeId]: {
    readonly _In: Types.Contravariant<In>
    readonly _Out: Types.Covariant<Out>
  }
}

type Untyped = MetricKeyType<any, any>

type Counter<A> = MetricKeyType<A, MetricState.MetricState.Counter<A>> & {
  readonly [CounterKeyTypeTypeId]: CounterKeyTypeTypeId
  readonly incremental: boolean
  readonly bigint: boolean
}

type Frequency = MetricKeyType<string, MetricState.MetricState.Frequency> & {
  readonly [FrequencyKeyTypeTypeId]: FrequencyKeyTypeTypeId
  readonly preregisteredWords: ReadonlyArray<string>
}

type Gauge<A> = MetricKeyType<A, MetricState.MetricState.Gauge<A>> & {
  readonly [GaugeKeyTypeTypeId]: GaugeKeyTypeTypeId
  readonly bigint: boolean
}

type Histogram = MetricKeyType<number, MetricState.MetricState.Histogram> & {
  readonly [HistogramKeyTypeTypeId]: HistogramKeyTypeTypeId
  readonly boundaries: MetricBoundaries.MetricBoundaries
}

type Summary = MetricKeyType<readonly [number, number], MetricState.MetricState.Summary> & {
  readonly [SummaryKeyTypeTypeId]: SummaryKeyTypeTypeId
  readonly maxAge: Duration.Duration
  readonly maxSize: number
  readonly error: number
  readonly quantiles: ReadonlyArray<number>
}

type InType<Type> = [Type] extends [
  {
    readonly [MetricKeyTypeTypeId]: {
      readonly _In: (_: infer In) => void
    }
  }
]
  ? In
  : never

type OutType<Type> = [Type] extends [
  {
    readonly [MetricKeyTypeTypeId]: {
      readonly _Out: (_: never) => infer Out
    }
  }
]
  ? Out
  : never