Domain

declare const Counter: Struct<{
  readonly _tag: Literal<"Counter">;
  readonly description: any;
  readonly name: String;
  state: any;
  readonly tags: $Array<Struct<{
    readonly key: String;
    readonly value: String;
  }>>;
}>

declare const ExternalSpan: Struct<{
  readonly _tag: Literal<"ExternalSpan">;
  readonly sampled: Boolean;
  readonly spanId: String;
  readonly traceId: String;
}>

interface ExternalSpan extends Type<typeof ExternalSpan> {}

interface ExternalSpanFrom extends Encoded<Struct<{
  readonly _tag: Literal<"ExternalSpan">;
  readonly sampled: Boolean;
  readonly spanId: String;
  readonly traceId: String;
}>> {}

declare const Frequency: Struct<{
  readonly _tag: Literal<"Frequency">;
  readonly description: any;
  readonly name: String;
  state: any;
  readonly tags: $Array<Struct<{
    readonly key: String;
    readonly value: String;
  }>>;
}>

declare const Gauge: Struct<{
  readonly _tag: Literal<"Gauge">;
  readonly description: any;
  readonly name: String;
  state: any;
  readonly tags: $Array<Struct<{
    readonly key: String;
    readonly value: String;
  }>>;
}>

declare const Histogram: Struct<{
  readonly _tag: Literal<"Histogram">;
  readonly description: any;
  readonly name: String;
  state: any;
  readonly tags: $Array<Struct<{
    readonly key: String;
    readonly value: String;
  }>>;
}>

declare function metric<Tag extends string, S, IS, R>(tag: Tag, state: any): Struct<{
  readonly _tag: Literal<Tag>;
  readonly description: any;
  readonly name: String;
  state: any;
  readonly tags: $Array<Struct<{
    readonly key: String;
    readonly value: String;
  }>>;
}>

declare const Metric: Union<readonly Array<Constraint>>

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

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

declare const MetricLabel: Struct<{
  readonly key: String;
  readonly value: String;
}>

declare const MetricsRequest: Struct<{
  readonly _tag: Literal<"MetricsRequest">;
}>

declare const MetricsSnapshot: Struct<{
  readonly _tag: Literal<"MetricsSnapshot">;
  readonly metrics: $Array<Union<readonly Array<Constraint>>>;
}>

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

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

declare const ParentSpan: Union<any>

type ParentSpan = Span | ExternalSpan

type ParentSpanFrom = SpanFrom | ExternalSpanFrom

declare const Ping: Struct<{
  readonly _tag: Literal<"Ping">;
}>

declare const Pong: Struct<{
  readonly _tag: Literal<"Pong">;
}>

declare const Request: Union<readonly Array<Constraint>>

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

declare const Response: Union<readonly Array<Constraint>>

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

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

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

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

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

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

declare const SpanStatus: Union<readonly Array<Constraint>>

declare const SpanStatusEnded: Struct<{
  readonly _tag: Literal<"Ended">;
  readonly endTime: BigInt;
  readonly startTime: BigInt;
}>

declare const SpanStatusStarted: Struct<{
  readonly _tag: Literal<"Started">;
  readonly startTime: BigInt;
}>

declare const Summary: Struct<{
  readonly _tag: Literal<"Summary">;
  readonly description: any;
  readonly name: String;
  state: any;
  readonly tags: $Array<Struct<{
    readonly key: String;
    readonly value: String;
  }>>;
}>