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

export 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>

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

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

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

export 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>>

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

export 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>

export 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
>

export declare class SocketCloseError

static is(u: unknown): u is SocketCloseError

static isClean(isClean: (code: number) => boolean)

export type SocketError = SocketGenericError | SocketCloseError

export declare class SocketGenericError

export declare const currentSendQueueCapacity: FiberRef.FiberRef<number>

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

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

export declare const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor>

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

toString()

readonly [CloseEventTypeId]: typeof CloseEventTypeId

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
  ) => Effect.Effect<void, SocketError | E, R>
  readonly runRaw: <_, E = never, R = never>(
    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void
  ) => Effect.Effect<void, SocketError | E, R>
  readonly writer: Effect.Effect<
    (chunk: Uint8Array | string | CloseEvent) => Effect.Effect<void, SocketError>,
    never,
    Scope.Scope
  >
}

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

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

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

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

export interface WebSocket {
  readonly _: unique symbol
}

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

export interface WebSocketConstructor {
  readonly _: unique symbol
}

export declare const CloseEventTypeId: typeof CloseEventTypeId

export type CloseEventTypeId = typeof CloseEventTypeId

export declare const SocketErrorTypeId: typeof SocketErrorTypeId

export type SocketErrorTypeId = typeof SocketErrorTypeId

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

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