declare const DisablePropagation: Context.Reference<DisablePropagation, boolean>

export interface DisablePropagation {
  readonly _: unique symbol
}

declare const externalSpan: (options: {
  readonly spanId: string
  readonly traceId: string
  readonly sampled?: boolean | undefined
  readonly context?: Context.Context<never> | undefined
}) => ExternalSpan

declare const make: (options: Omit<Tracer, typeof TracerTypeId>) => Tracer

declare const tracerWith: <A, E, R>(f: (tracer: Tracer) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>

type AnySpan = Span | ExternalSpan

export interface ExternalSpan {
  readonly _tag: "ExternalSpan"
  readonly spanId: string
  readonly traceId: string
  readonly sampled: boolean
  readonly context: Context.Context<never>
}

export interface Span {
  readonly _tag: "Span"
  readonly name: string
  readonly spanId: string
  readonly traceId: string
  readonly parent: Option.Option<AnySpan>
  readonly context: Context.Context<never>
  readonly status: SpanStatus
  readonly attributes: ReadonlyMap<string, unknown>
  readonly links: ReadonlyArray<SpanLink>
  readonly sampled: boolean
  readonly kind: SpanKind
  end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void
  attribute(key: string, value: unknown): void
  event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void
  addLinks(links: ReadonlyArray<SpanLink>): void
}

type SpanKind = "internal" | "server" | "client" | "producer" | "consumer"

export interface SpanLink {
  readonly _tag: "SpanLink"
  readonly span: AnySpan
  readonly attributes: Readonly<Record<string, unknown>>
}

export interface SpanOptions {
  readonly attributes?: Record<string, unknown> | undefined
  readonly links?: ReadonlyArray<SpanLink> | undefined
  readonly parent?: AnySpan | undefined
  readonly root?: boolean | undefined
  readonly context?: Context.Context<never> | undefined
  readonly kind?: SpanKind | undefined
  readonly captureStackTrace?: boolean | LazyArg<string | undefined> | undefined
}

type SpanStatus =
  | {
      _tag: "Started"
      startTime: bigint
    }
  | {
      _tag: "Ended"
      startTime: bigint
      endTime: bigint
      exit: Exit.Exit<unknown, unknown>
    }

declare const ParentSpan: Context.Tag<ParentSpan, AnySpan>

export interface ParentSpan {
  readonly _: unique symbol
}

declare const Tracer: Context.Tag<Tracer, Tracer>

export interface Tracer {
  readonly [TracerTypeId]: TracerTypeId
  span(
    name: string,
    parent: Option.Option<AnySpan>,
    context: Context.Context<never>,
    links: ReadonlyArray<SpanLink>,
    startTime: bigint,
    kind: SpanKind,
    options?: SpanOptions
  ): Span
  context<X>(f: () => X, fiber: Fiber.RuntimeFiber<any, any>): X
}

declare const TracerTypeId: unique symbol

type TracerTypeId = typeof TracerTypeId