schemas

export declare const Counter: any

export declare const ExternalSpan: any

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

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

export declare const Frequency: any

export declare const Gauge: any

export declare const Histogram: any

export declare const Metric: any

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

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

export declare const MetricLabel: any

export declare const MetricsRequest: any

export declare const MetricsSnapshot: any

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

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

export declare const ParentSpan: any

export type ParentSpan = Span | ExternalSpan

export type ParentSpanFrom = SpanFrom | ExternalSpanFrom

export declare const Ping: any

export declare const Pong: any

export declare const Request: any

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

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

export declare const Response: any

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

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

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

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

export declare const SpanStatus: any

export declare const SpanStatusEnded: any

export declare const SpanStatusStarted: any

export declare const Summary: any

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