export declare const counter: {
  (
    name: string,
    options?: {
      readonly description?: string | undefined
      readonly bigint?: false | undefined
      readonly incremental?: boolean | undefined
    }
  ): MetricKey.Counter<number>
  (
    name: string,
    options: {
      readonly description?: string | undefined
      readonly bigint: true
      readonly incremental?: boolean | undefined
    }
  ): MetricKey.Counter<bigint>
}

export declare const frequency: (
  name: string,
  options?:
    | { readonly description?: string | undefined; readonly preregisteredWords?: ReadonlyArray<string> | undefined }
    | undefined
) => MetricKey.Frequency

export declare const gauge: {
  (
    name: string,
    options?: { readonly description?: string | undefined; readonly bigint?: false | undefined }
  ): MetricKey.Gauge<number>
  (name: string, options: { readonly description?: string | undefined; readonly bigint: true }): MetricKey.Gauge<bigint>
}

export declare const histogram: (
  name: string,
  boundaries: MetricBoundaries.MetricBoundaries,
  description?: string
) => MetricKey.Histogram

export declare const summary: (options: {
  readonly name: string
  readonly maxAge: Duration.DurationInput
  readonly maxSize: number
  readonly error: number
  readonly quantiles: ReadonlyArray<number>
  readonly description?: string | undefined
}) => MetricKey.Summary

export declare const tagged: {
  (
    key: string,
    value: string
  ): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
  <Type extends MetricKeyType.MetricKeyType<any, any>>(
    self: MetricKey<Type>,
    key: string,
    value: string
  ): MetricKey<Type>
}

export declare const taggedWithLabels: {
  (
    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
  ): <Type extends MetricKeyType.MetricKeyType<any, any>>(self: MetricKey<Type>) => MetricKey<Type>
  <Type extends MetricKeyType.MetricKeyType<any, any>>(
    self: MetricKey<Type>,
    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
  ): MetricKey<Type>
}

export interface MetricKey<out Type extends MetricKeyType.MetricKeyType<any, any>>
  extends MetricKey.Variance<Type>,
    Equal.Equal,
    Pipeable {
  readonly name: string
  readonly keyType: Type
  readonly description: Option.Option<string>
  readonly tags: ReadonlyArray<MetricLabel.MetricLabel>
}

export declare const isMetricKey: (u: unknown) => u is MetricKey<MetricKeyType.MetricKeyType<unknown, unknown>>

export declare const MetricKeyTypeId: typeof MetricKeyTypeId

export type MetricKeyTypeId = typeof MetricKeyTypeId

export interface Variance<out Type> {
  readonly [MetricKeyTypeId]: {
    _Type: Types.Covariant<Type>
  }
}

export type Counter<A extends number | bigint> = MetricKey<MetricKeyType.MetricKeyType.Counter<A>>

export type Frequency = MetricKey<MetricKeyType.MetricKeyType.Frequency>

export type Gauge<A extends number | bigint> = MetricKey<MetricKeyType.MetricKeyType.Gauge<A>>

export type Histogram = MetricKey<MetricKeyType.MetricKeyType.Histogram>

export type Summary = MetricKey<MetricKeyType.MetricKeyType.Summary>

export type Untyped = MetricKey<any>