dfx 0.0.4 → 0.0.5

package/DiscordREST/types.d.ts

@@ -0,0 +1,7 @@
+import * as T from "@effect-ts/core/Effect";
+export declare type RESTError = {
+    _tag: "http";
+    code: number;
+    body?: unknown;
+};
+export declare type Response<T> = T.IO<RESTError, T>;

package/DiscordShard/commands.d.ts

@@ -0,0 +1,7 @@
+import { GatewayPayload, Heartbeat, Identify, RequestGuildMember, Resume, UpdatePresence, UpdateVoiceState } from "../types";
+export declare const heartbeat: (d: Heartbeat) => GatewayPayload;
+export declare const identify: (d: Identify) => GatewayPayload;
+export declare const resume: (d: Resume) => GatewayPayload;
+export declare const requestGuildMembers: (d: RequestGuildMember) => GatewayPayload;
+export declare const voiceStateUpdate: (d: UpdateVoiceState) => GatewayPayload;
+export declare const presenceUpdate: (d: UpdatePresence) => GatewayPayload;

package/DiscordShard/heartbeats.d.ts

@@ -0,0 +1,7 @@
+import * as S from "@effect-ts/core/Effect/Experimental/Stream";
+import * as H from "@effect-ts/core/Effect/Hub";
+import * as R from "@effect-ts/core/Effect/Ref";
+import * as O from "@effect-ts/core/Option";
+import * as DWS from "../DiscordWS";
+import { GatewayPayload } from "../types";
+export declare const fromHub: (hub: H.Hub<GatewayPayload<any>>, seqRef: R.Ref<O.Option<number>>) => S.Stream<import("@effect-ts/system/Has").Has<import("@effect-ts/system/Clock").Clock>, never, DWS.Message>;

package/DiscordShard/identify.d.ts

@@ -0,0 +1,16 @@
+import * as S from "@effect-ts/core/Effect/Experimental/Stream";
+import * as H from "@effect-ts/core/Effect/Hub";
+import * as R from "@effect-ts/core/Effect/Ref";
+import * as O from "@effect-ts/core/Option";
+import { GatewayPayload, ReadyEvent, UpdatePresence } from "../types";
+export interface Options {
+    token: string;
+    intents: number;
+    shard: [number, number];
+    presence?: UpdatePresence;
+}
+export interface Requirements {
+    latestReady: R.Ref<O.Option<ReadyEvent>>;
+    latestSequence: R.Ref<O.Option<number>>;
+}
+export declare const fromHub: (hub: H.Hub<GatewayPayload<any>>, { latestReady, latestSequence, ...opts }: Options & Requirements) => S.Stream<unknown, never, GatewayPayload<any>>;

package/DiscordShard/index.d.ts

@@ -0,0 +1,32 @@
+import * as T from "@effect-ts/core/Effect";
+import * as L from "@effect-ts/core/Effect/Layer";
+import * as S from "@effect-ts/core/Effect/Experimental/Stream";
+import * as H from "@effect-ts/core/Effect/Hub";
+import * as M from "@effect-ts/core/Effect/Managed";
+import * as DWS from "../DiscordWS";
+import { GatewayEvent, GatewayPayload } from "../types";
+import * as Identify from "./identify";
+declare const makeService: () => {
+    readonly _tag: "DiscordShardService";
+    readonly make: (opts: Identify.Options) => M.Managed<unknown, never, {
+        readonly run: T.RIO<import("@effect-ts/system/Has").Has<DWS.DiscordWS> & import("@effect-ts/system/Has").Has<import("../WS").WS> & import("@effect-ts/system/Clock").HasClock & import("@effect-ts/system/Has").Has<import("../Log").Log> & import("@effect-ts/system/Has").Has<import("@effect-ts/system/Clock").Clock>, void>;
+        readonly raw: H.Hub<GatewayPayload<any>>;
+        readonly dispatch: H.Hub<GatewayPayload<GatewayEvent>>;
+        readonly fromDispatch: <K extends keyof import("../types").GatewayEvents>(event: K) => S.Stream<unknown, never, import("../types").GatewayEvents[K]>;
+        readonly send: (p: GatewayPayload) => T.Effect<unknown, never, boolean>;
+        readonly reconnect: () => T.Effect<unknown, never, boolean>;
+    }>;
+};
+export interface DiscordShard extends ReturnType<typeof makeService> {
+}
+export declare const DiscordShard: import("@effect-ts/system/Has").Tag<DiscordShard>;
+export declare const LiveDiscordShard: L.Layer<{}, never, import("@effect-ts/system/Has").Has<DiscordShard>>;
+export declare const make: (opts: Identify.Options) => M.Managed<import("@effect-ts/system/Has").Has<DiscordShard>, never, {
+    readonly run: T.RIO<import("@effect-ts/system/Has").Has<DWS.DiscordWS> & import("@effect-ts/system/Has").Has<import("../WS").WS> & import("@effect-ts/system/Clock").HasClock & import("@effect-ts/system/Has").Has<import("../Log").Log> & import("@effect-ts/system/Has").Has<import("@effect-ts/system/Clock").Clock>, void>;
+    readonly raw: H.Hub<GatewayPayload<any>>;
+    readonly dispatch: H.Hub<GatewayPayload<GatewayEvent>>;
+    readonly fromDispatch: <K extends keyof import("../types").GatewayEvents>(event: K) => S.Stream<unknown, never, import("../types").GatewayEvents[K]>;
+    readonly send: (p: GatewayPayload) => T.Effect<unknown, never, boolean>;
+    readonly reconnect: () => T.Effect<unknown, never, boolean>;
+}>;
+export {};

package/DiscordShard/invalidSession.d.ts

@@ -0,0 +1,7 @@
+import * as S from "@effect-ts/core/Effect/Experimental/Stream";
+import * as H from "@effect-ts/core/Effect/Hub";
+import * as R from "@effect-ts/core/Effect/Ref";
+import * as O from "@effect-ts/core/Option";
+import { Message } from "../DiscordWS";
+import { GatewayPayload, ReadyEvent } from "../types";
+export declare const fromHub: (hub: H.Hub<GatewayPayload<any>>, latestReady: R.Ref<O.Option<ReadyEvent>>) => S.Stream<unknown, never, Message>;

package/DiscordShard/utils.d.ts

@@ -0,0 +1,9 @@
+import * as T from "@effect-ts/core/Effect";
+import * as S from "@effect-ts/core/Effect/Experimental/Stream";
+import * as H from "@effect-ts/core/Effect/Hub";
+import * as R from "@effect-ts/core/Effect/Ref";
+import * as O from "@effect-ts/core/Option";
+import { GatewayEvent, GatewayEvents, GatewayOpcode, GatewayPayload } from "../types";
+export declare const opCode: (hub: H.Hub<GatewayPayload<any>>) => <T = any>(code: GatewayOpcode) => S.UIO<GatewayPayload<T>>;
+export declare const latest: <T>(f: (p: GatewayPayload) => O.Option<T>) => T.Effect<unknown, never, readonly [R.Ref<O.Option<T>>, <R, E>(self: S.Stream<R, E, GatewayPayload<any>>) => S.Stream<R, E, GatewayPayload<any>>]>;
+export declare const fromDispatch: (hub: H.Hub<GatewayPayload<GatewayEvent>>) => <K extends keyof GatewayEvents>(event: K) => S.Stream<unknown, never, GatewayEvents[K]>;

package/DiscordWS/index.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import * as T from "@effect-ts/core/Effect";
+import * as S from "@effect-ts/core/Effect/Experimental/Stream";
+import { RawData } from "ws";
+import { GatewayPayload } from "../types";
+import * as WS from "../WS";
+export declare type Message = GatewayPayload | WS.Reconnect;
+export interface OpenOpts {
+    url?: string;
+    version?: number;
+    encoding?: Encoding;
+    outgoing: WS.OutboundStream<Message>;
+}
+export interface Encoding {
+    type: "json" | "etf";
+    encode: (p: GatewayPayload) => string | Buffer | ArrayBuffer;
+    decode: (p: RawData) => GatewayPayload;
+}
+export declare const jsonEncoding: Encoding;
+declare const openImpl: ({ url, version, encoding, outgoing, }: OpenOpts) => S.Stream<import("@effect-ts/system/Has").Has<WS.WS> & import("@effect-ts/system/Clock").HasClock & import("@effect-ts/system/Has").Has<import("../Log").Log>, unknown, GatewayPayload<any>>;
+export declare type Connection = ReturnType<typeof openImpl>;
+declare const service: {
+    readonly _tag: "DiscordWSService";
+    readonly open: ({ url, version, encoding, outgoing, }: OpenOpts) => S.Stream<import("@effect-ts/system/Has").Has<WS.WS> & import("@effect-ts/system/Clock").HasClock & import("@effect-ts/system/Has").Has<import("../Log").Log>, unknown, GatewayPayload<any>>;
+};
+declare type Service = typeof service;
+export interface DiscordWS extends Service {
+}
+export declare const DiscordWS: import("@effect-ts/system/Has").Tag<DiscordWS>;
+export declare const LiveDiscordWS: import("@effect-ts/system/Layer").Layer<unknown, never, import("@effect-ts/system/Has").Has<DiscordWS>>;
+export declare const open: (opts: OpenOpts) => T.Effect<import("@effect-ts/system/Has").Has<DiscordWS>, never, S.Stream<import("@effect-ts/system/Has").Has<WS.WS> & import("@effect-ts/system/Clock").HasClock & import("@effect-ts/system/Has").Has<import("../Log").Log>, unknown, GatewayPayload<any>>>;
+export {};

package/Log/index.d.ts

@@ -0,0 +1,12 @@
+import * as T from "@effect-ts/core/Effect";
+declare const service: {
+    readonly _tag: "LogService";
+    readonly log: (...args: any[]) => T.UIO<void>;
+};
+declare type Service = typeof service;
+export interface Log extends Service {
+}
+export declare const Log: import("@effect-ts/system/Has").Tag<Log>;
+export declare const LiveLog: import("@effect-ts/system/Layer").Layer<unknown, never, import("@effect-ts/system/Has").Has<Log>>;
+export declare const log: (...args: any[]) => T.Effect<import("@effect-ts/system/Has").Has<Log>, never, void>;
+export {};

package/WS/index.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import * as T from "@effect-ts/core/Effect";
+import * as S from "@effect-ts/core/Effect/Experimental/Stream";
+import type { _A } from "@effect-ts/core/Utils";
+import { HasClock } from "@effect-ts/system/Clock";
+import * as Ws from "ws";
+export declare type WsError = {
+    _tag: "close";
+    code: number;
+    reason: string;
+} | {
+    _tag: "error";
+    cause: unknown;
+} | {
+    _tag: "write";
+    cause: unknown;
+};
+export declare type WebSocketStream<T = Ws.RawData> = S.Stream<HasClock, WsError, T>;
+export declare const Reconnect: unique symbol;
+export declare type Reconnect = typeof Reconnect;
+export declare type Message = string | Buffer | ArrayBuffer | Reconnect;
+export declare type OutboundStream<T = Message> = S.UIO<T>;
+declare const makeWS: T.Effect<unknown, never, {
+    readonly _tag: "WSService";
+    readonly open: (url: string, out: OutboundStream<Message>, options?: Ws.ClientOptions | undefined) => WebSocketStream<Ws.RawData>;
+}>;
+export interface WS extends _A<typeof makeWS> {
+}
+export declare const WS: import("@effect-ts/system/Has").Tag<WS>;
+export declare const LiveWS: import("@effect-ts/system/Layer").Layer<unknown, never, import("@effect-ts/system/Has").Has<WS>>;
+export declare const open: (url: string, out: OutboundStream<Message>, options?: Ws.ClientOptions | undefined) => T.Effect<import("@effect-ts/system/Has").Has<WS>, never, WebSocketStream<Ws.RawData>>;
+export {};

package/bot.d.ts

@@ -0,0 +1 @@
+export {};

package/mod.d.ts

@@ -0,0 +1,3 @@
+import * as Shard from "./DiscordShard";
+import * as WS from "./WS";
+export declare const DefaultEnv: import("@effect-ts/system/Layer").Layer<unknown, never, import("@effect-ts/system/Has").Has<WS.WS> & import("@effect-ts/system/Has").Has<import("./DiscordWS").DiscordWS> & import("@effect-ts/system/Has").Has<Shard.DiscordShard> & import("@effect-ts/system/Has").Has<import("./Log").Log>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dfx",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Effect-TS discord library",
   "main": "mod.js",
   "author": "Tim Smart <tim.smart@arisechurch.com>",
@@ -13,6 +13,7 @@
   },
   "files": [
     "**/*.ts",
+    "**/*.d.ts",
     "**/*.js",
     "**/*.js.map",
     "!discord-api-docs/**/*"