declare const make: (options: {
  readonly apiKey?: Redacted.Redacted | undefined
  readonly apiUrl?: string | undefined
  readonly anthropicVersion?: string | undefined
  readonly organizationId?: Redacted.Redacted | undefined
  readonly projectId?: Redacted.Redacted | undefined
  readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
}) => Effect.Effect<Service, never, HttpClient.HttpClient | Scope.Scope>

declare class AnthropicClient

declare const layer: (options: {
  readonly apiKey?: Redacted.Redacted | undefined
  readonly apiUrl?: string | undefined
  readonly anthropicVersion?: string | undefined
  readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
}) => Layer.Layer<AnthropicClient, never, HttpClient.HttpClient>

declare const layerConfig: (options: {
  readonly apiKey?: Config.Config<Redacted.Redacted | undefined> | undefined
  readonly apiUrl?: Config.Config<string | undefined> | undefined
  readonly anthropicVersion?: Config.Config<string | undefined> | undefined
  readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
}) => Layer.Layer<AnthropicClient, ConfigError, HttpClient.HttpClient>

type MessageStreamEvent = typeof MessageStreamEvent.Type

export interface Service {
  /**
   * The underlying HTTP client capable of communicating with the Anthropic API.
   *
   * This client is pre-configured with authentication, base URL, and standard
   * headers required for Anthropic API communication. It provides direct access
   * to the generated Anthropic API client for operations not covered by the
   * higher-level methods.
   *
   * Use this when you need to:
   * - Access provider-specific API endpoints not available through the AI SDK
   * - Implement custom request/response handling
   * - Use Anthropic API features not yet supported by the Effect AI abstractions
   * - Perform batch operations or non-streaming requests
   *
   * The client automatically handles authentication and follows Anthropic's
   * API conventions for request formatting and error handling.
   */
  readonly client: Generated.Client

  readonly streamRequest: <A, I, R>(
    request: HttpClientRequest.HttpClientRequest,
    schema: Schema.Schema<A, I, R>
  ) => Stream.Stream<A, AiError.AiError, R>

  readonly createMessage: (options: {
    readonly params?: typeof Generated.BetaMessagesPostParams.Encoded | undefined
    readonly payload: typeof Generated.BetaCreateMessageParams.Encoded
  }) => Effect.Effect<Generated.BetaMessage, AiError.AiError>

  readonly createMessageStream: (options: {
    readonly params?: typeof Generated.BetaMessagesPostParams.Encoded | undefined
    readonly payload: Omit<typeof Generated.BetaCreateMessageParams.Encoded, "stream">
  }) => Stream.Stream<MessageStreamEvent, AiError.AiError>
}

declare class CitationsDelta

declare class ContentBlockDeltaEvent

declare class ContentBlockStartEvent

declare class ContentBlockStopEvent

declare class ErrorEvent

declare class InputJsonContentBlockDelta

declare class MessageDelta

declare class MessageDeltaEvent

declare class MessageDeltaUsage

declare class MessageStartEvent

declare class MessageStopEvent

declare const MessageStreamEvent: Schema.Union<
  [
    typeof PingEvent,
    typeof ErrorEvent,
    typeof MessageStartEvent,
    typeof MessageDeltaEvent,
    typeof MessageStopEvent,
    typeof ContentBlockStartEvent,
    typeof ContentBlockDeltaEvent,
    typeof ContentBlockStopEvent
  ]
>

declare class PingEvent

declare class ServerToolUsage

declare class SignatureContentBlockDelta

declare class TextContentBlockDelta

declare class ThinkingContentBlockDelta