schemas

declare const Counter: any

declare const ExternalSpan: any

export interface ExternalSpan extends Schema.Schema.Type<typeof ExternalSpan> {}

export interface ExternalSpanFrom extends Schema.Schema.Encoded<typeof ExternalSpan> {}

declare const Frequency: any

declare const Gauge: any

declare const Histogram: any

declare const Metric: any

type Metric = Schema.Schema.Type<typeof Metric>

type MetricFrom = Schema.Schema.Encoded<typeof Metric>

declare const MetricLabel: any

declare const MetricsRequest: any

declare const MetricsSnapshot: any

type MetricsSnapshot = Schema.Schema.Type<typeof MetricsSnapshot>

type MetricsSnapshotFrom = Schema.Schema.Encoded<typeof MetricsSnapshot>

declare const ParentSpan: any

type ParentSpan = Span | ExternalSpan

type ParentSpanFrom = SpanFrom | ExternalSpanFrom

declare const Ping: any

declare const Pong: any

declare const Request: any

type Request = Schema.Schema.Type<typeof Request>

type WithoutPing = Exclude<Request, { readonly _tag: "Ping" }>

declare const Response: any

type Response = Schema.Schema.Type<typeof Response>

type WithoutPong = Exclude<Response, { readonly _tag: "Pong" }>

declare const Span: Schema.Schema<Span, SpanFrom>

export interface Span {
  readonly _tag: "Span"
  readonly spanId: string
  readonly traceId: string
  readonly name: string
  readonly sampled: boolean
  readonly attributes: ReadonlyMap<string, unknown>
  readonly parent: Option<ParentSpan>
  readonly status:
    | {
        readonly _tag: "Started"
        readonly startTime: bigint
      }
    | {
        readonly _tag: "Ended"
        readonly startTime: bigint
        readonly endTime: bigint
      }
}

declare const SpanEvent: Schema.Schema<
  SpanEvent,
  {
    readonly _tag: "SpanEvent"
    readonly spanId: string
    readonly traceId: string
    readonly name: string
    readonly attributes: { readonly [x: string]: unknown }
    readonly startTime: string
  }
>

export interface SpanEvent {
  readonly _tag: "SpanEvent"
  readonly spanId: string
  readonly traceId: string
  readonly name: string
  readonly attributes: { readonly [x: string]: unknown }
  readonly startTime: bigint
}

export interface SpanFrom {
  readonly _tag: "Span"
  readonly spanId: string
  readonly traceId: string
  readonly name: string
  readonly sampled: boolean
  readonly attributes: ReadonlyArray<readonly [string, unknown]>
  readonly parent: Schema.OptionEncoded<ParentSpanFrom>
  readonly status:
    | {
        readonly _tag: "Started"
        readonly startTime: string
      }
    | {
        readonly _tag: "Ended"
        readonly startTime: string
        readonly endTime: string
      }
}

declare const SpanStatus: any

declare const SpanStatusEnded: any

declare const SpanStatusStarted: any

declare const Summary: any

declare const metric: <Tag extends string, S, IS, R>(tag: Tag, state: Schema.Schema<S, IS, R>) => any