Socket

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

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

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

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

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

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

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

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

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

declare class SocketCloseError extends YieldableError<this> & Record<typeof SocketErrorTypeId, typeof SocketErrorTypeId> & {
  readonly _tag: "SocketError";
} & Readonly<{
  readonly closeReason?: string;
  readonly code: number;
  readonly reason: "Close";
}> {
  constructor(args: {
    readonly closeReason?: string;
    readonly code: number;
    readonly reason: "Close";
  });
  message: string;
  static is(u: unknown): u is SocketCloseError;
  static isClean(isClean: (code: number) => boolean): (u: unknown) => u is SocketCloseError;
}

type SocketError = SocketGenericError | SocketCloseError

declare class SocketGenericError extends YieldableError<this> & Record<typeof SocketErrorTypeId, typeof SocketErrorTypeId> & {
  readonly _tag: "SocketError";
} & Readonly<{
  readonly cause: unknown;
  readonly reason: "Write" | "Read" | "Open" | "OpenTimeout";
}> {
  constructor(args: {
    readonly cause: unknown;
    readonly reason: "Write" | "Read" | "Open" | "OpenTimeout";
  });
  message: string;
}

declare const currentSendQueueCapacity: FiberRef.FiberRef<number>

declare function isSocket(u: unknown): u is Socket

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

declare const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor>

declare class CloseEvent {
  constructor(code: number, reason?: string);
  readonly [CloseEventTypeId]: typeof CloseEventTypeId;
  readonly code: number;
  readonly reason?: string;
  toString(): string;
}

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

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

declare function defaultCloseCodeIsError(code: number): boolean

declare function isCloseEvent(u: unknown): u is CloseEvent

declare function isSocketError(u: unknown): u is SocketError

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

declare const WebSocket: Tag<WebSocket, WebSocket>

interface WebSocket {
  readonly _: typeof _;
}

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

interface WebSocketConstructor {
  readonly _: typeof _;
}

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