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;