declare const toChannel: <IE>(
  self: Socket
) => Channel.Channel<
  Chunk.Chunk<Uint8Array>,
  Chunk.Chunk<Uint8Array | string | CloseEvent>,
  SocketError | IE,
  IE,
  void,
  unknown
>

declare const toChannelMap: <IE, A>(
  self: Socket,
  f: (data: Uint8Array | string) => A
) => Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<Uint8Array | string | CloseEvent>, SocketError | IE, IE, void, unknown>

declare const toChannelString: {
  (
    encoding?: string | undefined
  ): <IE>(
    self: Socket
  ) => Channel.Channel<
    Chunk.Chunk<string>,
    Chunk.Chunk<Uint8Array | string | CloseEvent>,
    SocketError | IE,
    IE,
    void,
    unknown
  >
  <IE>(
    self: Socket,
    encoding?: string | undefined
  ): Channel.Channel<
    Chunk.Chunk<string>,
    Chunk.Chunk<Uint8Array | string | CloseEvent>,
    SocketError | IE,
    IE,
    void,
    unknown
  >
}

declare const toChannelWith: <IE = never>() => (
  self: Socket
) => Channel.Channel<
  Chunk.Chunk<Uint8Array>,
  Chunk.Chunk<Uint8Array | string | CloseEvent>,
  SocketError | IE,
  IE,
  void,
  unknown
>

declare const fromTransformStream: <R>(
  acquire: Effect.Effect<InputTransformStream, SocketError, R>,
  options?: { readonly closeCodeIsError?: (code: number) => boolean }
) => Effect.Effect<Socket, never, Exclude<R, Scope.Scope>>

declare const fromWebSocket: <RO>(
  acquire: Effect.Effect<globalThis.WebSocket, SocketError, RO>,
  options?: { readonly closeCodeIsError?: (code: number) => boolean; readonly openTimeout?: DurationInput }
) => Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>>

declare const makeChannel: <IE = never>() => Channel.Channel<
  Chunk.Chunk<Uint8Array>,
  Chunk.Chunk<Uint8Array | string | CloseEvent>,
  SocketError | IE,
  IE,
  void,
  unknown,
  Socket
>

declare const makeWebSocket: (
  url: string | Effect.Effect<string>,
  options?: {
    readonly closeCodeIsError?: ((code: number) => boolean) | undefined
    readonly openTimeout?: DurationInput | undefined
    readonly protocols?: string | Array<string> | undefined
  }
) => Effect.Effect<Socket, never, WebSocketConstructor>

declare const makeWebSocketChannel: <IE = never>(
  url: string,
  options?: { readonly closeCodeIsError?: (code: number) => boolean }
) => Channel.Channel<
  Chunk.Chunk<Uint8Array>,
  Chunk.Chunk<Uint8Array | string | CloseEvent>,
  SocketError | IE,
  IE,
  void,
  unknown,
  WebSocketConstructor
>

declare class SocketCloseError

declare const is: (u: unknown) => u is SocketCloseError

declare const isClean: (isClean: (code: number) => boolean) => (u: unknown) => u is SocketCloseError

type SocketError = SocketGenericError | SocketCloseError

declare class SocketGenericError

declare const currentSendQueueCapacity: FiberRef.FiberRef<number>

declare const isSocket: (u: unknown) => u is Socket

declare const layerWebSocket: (
  url: string,
  options?: { readonly closeCodeIsError?: (code: number) => boolean }
) => Layer.Layer<Socket, never, WebSocketConstructor>

declare const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor, never, never>

declare class CloseEvent { constructor(readonly code = 1000, readonly reason?: string) }

declare const toString: () => string

readonly [CloseEventTypeId]: unique symbol

export interface InputTransformStream {
  readonly readable: ReadableStream<Uint8Array> | ReadableStream<string> | ReadableStream<Uint8Array | string>
  readonly writable: WritableStream<Uint8Array>
}

export interface Socket {
  readonly [TypeId]: TypeId
  readonly run: <_, E = never, R = never>(
    handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void,
    options?: {
      readonly onOpen?: Effect.Effect<void> | undefined
    }
  ) => Effect.Effect<void, SocketError | E, R>
  readonly runRaw: <_, E = never, R = never>(
    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void,
    options?: {
      readonly onOpen?: Effect.Effect<void> | undefined
    }
  ) => Effect.Effect<void, SocketError | E, R>
  readonly writer: Effect.Effect<
    (chunk: Uint8Array | string | CloseEvent) => Effect.Effect<void, SocketError>,
    never,
    Scope.Scope
  >
}

declare const isCloseEvent: (u: unknown) => u is CloseEvent

declare const isSocketError: (u: unknown) => u is SocketError

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

declare const WebSocket: Context.Tag<WebSocket, globalThis.WebSocket>

export interface WebSocket {
  readonly _: unique symbol
}

declare const WebSocketConstructor: Context.Tag<
  WebSocketConstructor,
  (url: string, protocols?: string | Array<string> | undefined) => globalThis.WebSocket
>

export interface WebSocketConstructor {
  readonly _: unique symbol
}

declare const CloseEventTypeId: unique symbol

type CloseEventTypeId = typeof CloseEventTypeId

declare const SocketErrorTypeId: unique symbol

type SocketErrorTypeId = typeof SocketErrorTypeId

declare const TypeId: unique symbol

type TypeId = typeof TypeId

declare const defaultCloseCodeIsError: (code: number) => boolean