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

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

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

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

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

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

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

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

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

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

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

export declare const CounterKeyTypeTypeId: typeof CounterKeyTypeTypeId

export type CounterKeyTypeTypeId = typeof CounterKeyTypeTypeId

export declare const FrequencyKeyTypeTypeId: typeof FrequencyKeyTypeTypeId

export type FrequencyKeyTypeTypeId = typeof FrequencyKeyTypeTypeId

export declare const GaugeKeyTypeTypeId: typeof GaugeKeyTypeTypeId

export type GaugeKeyTypeTypeId = typeof GaugeKeyTypeTypeId

export declare const HistogramKeyTypeTypeId: typeof HistogramKeyTypeTypeId

export type HistogramKeyTypeTypeId = typeof HistogramKeyTypeTypeId

export declare const MetricKeyTypeTypeId: typeof MetricKeyTypeTypeId

export type MetricKeyTypeTypeId = typeof MetricKeyTypeTypeId

export declare const SummaryKeyTypeTypeId: typeof SummaryKeyTypeTypeId

export type SummaryKeyTypeTypeId = typeof SummaryKeyTypeTypeId

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

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

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

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

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

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

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

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

export type Untyped = MetricKeyType<any, any>