@effect-ak/tg-bot 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,113 @@
+import * as effect_Types from 'effect/Types';
+import { Api, Update } from '@effect-ak/tg-bot-api';
+import * as effect_Cause from 'effect/Cause';
+import * as _effect_ak_tg_bot_client from '@effect-ak/tg-bot-client';
+import { TgBotClientError } from '@effect-ak/tg-bot-client';
+import * as Micro from 'effect/Micro';
+import * as Data from 'effect/Data';
+import * as Context from 'effect/Context';
+
+type BotResult = {
+    [K in keyof Api]: K extends `send_${infer R}` ? {
+        type: R;
+    } & Omit<Parameters<Api[K]>[0], "chat_id"> : never;
+}[keyof Api];
+declare const BotResponse_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
+    readonly _tag: "BotResponse";
+};
+declare class BotResponse extends BotResponse_base<{
+    response?: BotResult;
+}> {
+    static make(result: BotResult): BotResponse;
+    static readonly ignore: BotResponse;
+}
+
+declare const BotUpdateHandlersTag_base: Context.TagClass<BotUpdateHandlersTag, "BotUpdateHandlers", BotMode>;
+declare class BotUpdateHandlersTag extends BotUpdateHandlersTag_base {
+}
+interface PollSettings {
+    log_level: "info" | "debug";
+    on_error: "stop" | "continue";
+    batch_size: number;
+    poll_timeout: number;
+    max_empty_responses: number | undefined;
+}
+declare class BotPollSettings extends Data.Class<PollSettings> {
+    static make(input: Partial<PollSettings>): BotPollSettings;
+}
+declare const BotPollSettingsTag_base: Context.ReferenceClass<BotPollSettings, "BotSettings", BotPollSettings>;
+declare class BotPollSettingsTag extends BotPollSettingsTag_base {
+}
+
+interface RunBotInput {
+    bot_token: string;
+    mode: BotMode;
+    poll?: Partial<PollSettings>;
+}
+type ExtractedUpdate<K extends AvailableUpdateTypes> = {
+    type: K;
+} & Update[K];
+type AvailableUpdateTypes = Exclude<keyof Update, "update_id">;
+type HandleUpdateFunction<U> = (update: U) => BotResponse | PromiseLike<BotResponse>;
+type BotUpdatesHandlers = {
+    readonly [K in AvailableUpdateTypes as `on_${K}`]?: HandleUpdateFunction<NonNullable<Update[K]>>;
+};
+interface HandleBatchUpdateFunction {
+    readonly on_batch: (update: Update[]) => boolean | PromiseLike<boolean>;
+}
+interface BotSingleMode extends BotUpdatesHandlers {
+    type: "single";
+}
+interface BotBatchMode extends HandleBatchUpdateFunction {
+    type: "batch";
+}
+type BotMode = BotSingleMode | BotBatchMode;
+
+declare const extractUpdate: <U extends AvailableUpdateTypes>(input: Update) => ExtractedUpdate<U> | undefined;
+declare class BatchUpdateResult extends Data.Class<{
+    hasErrors: boolean;
+    updates: Update[];
+}> {
+}
+declare const handleUpdates: (updates: Update[]) => Micro.Micro<BatchUpdateResult, never, BotUpdateHandlersTag | _effect_ak_tg_bot_client.TgBotApiToken>;
+declare const handleEntireBatch: (updates: Update[], handlers: HandleBatchUpdateFunction) => Micro.Micro<BatchUpdateResult, never, never>;
+declare const HandleUpdateError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "HandleUpdateError";
+} & Readonly<A>;
+declare class HandleUpdateError extends HandleUpdateError_base<{
+    name: "UnknownUpdate" | "HandlerNotDefined" | "BotHandlerError";
+    update: Update;
+    cause?: unknown;
+}> {
+}
+declare const handleOneByOne: (updates: Update[], handlers: BotUpdatesHandlers, pollSettings: PollSettings) => Micro.Micro<BatchUpdateResult, never, _effect_ak_tg_bot_client.TgBotApiToken>;
+declare const handleOneUpdate: (updateObject: Update, handlers: BotUpdatesHandlers) => Micro.Micro<HandleUpdateError | undefined, HandleUpdateError | _effect_ak_tg_bot_client.TgBotClientError, _effect_ak_tg_bot_client.TgBotApiToken>;
+
+declare const FetchUpdatesError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "FetchUpdatesError";
+} & Readonly<A>;
+declare class FetchUpdatesError extends FetchUpdatesError_base<{
+    name: "TooManyEmptyResponses" | "NoUpdatesToCommit";
+}> {
+}
+
+type BotInstance = Micro.Micro.Success<ReturnType<typeof launchBot>>;
+declare const launchBot: (input: RunBotInput) => Micro.Micro<{
+    readonly reload: (mode: BotMode) => Promise<void>;
+    readonly fiber: () => Micro.MicroFiber<BatchUpdateResult, _effect_ak_tg_bot_client.TgBotClientError | FetchUpdatesError> | undefined;
+}, never, never>;
+
+declare const BotRunService_base: Context.ReferenceClass<BotRunService, "BotRunService", {
+    readonly runBotInBackground: Micro.Micro<void, never, BotUpdateHandlersTag | _effect_ak_tg_bot_client.TgBotApiToken>;
+    readonly getFiber: () => Micro.MicroFiber<BatchUpdateResult, TgBotClientError | FetchUpdatesError> | undefined;
+}>;
+declare class BotRunService extends BotRunService_base {
+}
+
+declare const runTgChatBot: (input: RunBotInput) => Promise<{
+    readonly reload: (mode: BotMode) => Promise<void>;
+    readonly fiber: () => Micro.MicroFiber<BatchUpdateResult, _effect_ak_tg_bot_client.TgBotClientError | FetchUpdatesError> | undefined;
+}>;
+declare const defineBot: (input: BotUpdatesHandlers) => BotUpdatesHandlers;
+
+export { type AvailableUpdateTypes, BatchUpdateResult, type BotBatchMode, type BotInstance, type BotMode, BotPollSettings, BotPollSettingsTag, BotResponse, BotRunService, type BotSingleMode, BotUpdateHandlersTag, type BotUpdatesHandlers, type ExtractedUpdate, type HandleBatchUpdateFunction, HandleUpdateError, type HandleUpdateFunction, type PollSettings, type RunBotInput, defineBot, extractUpdate, handleEntireBatch, handleOneByOne, handleOneUpdate, handleUpdates, launchBot, runTgChatBot };