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