@grom.js/effect-tg 0.3.1 → 0.5.0

package/src/internal/dialog.ts

@@ -0,0 +1,33 @@
+export function PeerId<Tag extends string>({
+  tag,
+  isValid,
+  toDialogId,
+}: {
+  tag: Tag
+  isValid: (peerId: number) => boolean
+  toDialogId: (peerId: number) => number
+}): {
+  new (id: number): {
+    readonly _tag: Tag
+    readonly id: number
+    readonly dialogId: number
+  }
+} {
+  class Base {
+    public readonly _tag = tag
+    public readonly id: number
+    public readonly dialogId: number
+
+    constructor(id: number) {
+      if (!Number.isSafeInteger(id)) {
+        throw new TypeError(`invalid integer: ${id}`)
+      }
+      if (!isValid(id)) {
+        throw new Error(`invalid peer id: ${id}`)
+      }
+      this.id = id
+      this.dialogId = toDialogId(id)
+    }
+  }
+  return Base
+}

package/src/internal/runner.ts

@@ -0,0 +1,57 @@
+import type { BotApiError } from '../BotApi.ts'
+import type { BotApiTransportError } from '../BotApiTransport.ts'
+import type { Runner } from '../Runner.ts'
+import * as Duration from 'effect/Duration'
+import * as Effect from 'effect/Effect'
+import * as Match from 'effect/Match'
+import * as Schedule from 'effect/Schedule'
+import { Update } from '../Bot.ts'
+import { BotApi } from '../BotApi.ts'
+
+export const makeSimple = (options?: {
+  allowedUpdates?: string[]
+}): Runner<BotApiError | BotApiTransportError, BotApi> => ({
+  run: Effect.fnUntraced(
+    function* (bot) {
+      const { allowedUpdates } = options ?? {}
+      const api = yield* BotApi
+      let lastUpdateId: undefined | number
+      while (true) {
+        const [update] = yield* api
+          .getUpdates({
+            offset: lastUpdateId == null ? undefined : lastUpdateId + 1,
+            allowed_updates: allowedUpdates,
+            timeout: 30,
+            limit: 1,
+          })
+          .pipe(
+            Effect.retry({
+              schedule: Schedule.spaced(Duration.seconds(3)),
+              while: error => Match.value(error).pipe(
+                Match.tagsExhaustive({
+                  '@grom.js/effect-tg/BotApi/BotApiError': error => Effect.succeed(
+                    error.code >= 500 || (
+                      error.code !== 401
+                      && error.code !== 403
+                      && error.code !== 404
+                    ),
+                  ),
+                  '@grom.js/effect-tg/BotApiTransport/BotApiTransportError': () => Effect.succeed(true),
+                }),
+              ),
+            }),
+          )
+        if (update) {
+          yield* Effect
+            .provideService(bot, Update, update)
+            .pipe(
+              Effect.catchAll(error => (
+                Effect.logError('Error in bot:', error)
+              )),
+            )
+          lastUpdateId = update.update_id
+        }
+      }
+    },
+  ),
+})

package/src/internal/send.ts

@@ -0,0 +1,318 @@
+import type * as Content from '../Content.ts'
+import type * as Dialog from '../Dialog.ts'
+import type * as Dialog_ from '../Dialog.ts'
+import type * as Markup from '../Markup.ts'
+import type * as Send from '../Send.ts'
+import type * as Text from '../Text.ts'
+import * as Tgx from '@grom.js/tgx'
+import * as Duration from 'effect/Duration'
+import * as Effect from 'effect/Effect'
+import * as Function from 'effect/Function'
+import * as Match from 'effect/Match'
+import * as Option from 'effect/Option'
+import * as BotApi from '../BotApi.ts'
+import * as LinkPreview from '../LinkPreview.ts'
+
+type ParamsText = PickMethodParams<'sendMessage', 'text' | 'entities' | 'parse_mode'>
+const paramsText: (text: Text.Text) => ParamsText = Function.pipe(
+  Match.type<Text.Text>(),
+  Match.withReturnType<ParamsText>(),
+  Match.tags({
+    Plain: ({ text, entities }) => ({ text, entities }),
+    Html: ({ html }) => ({ text: html, parse_mode: 'HTML' }),
+    Markdown: ({ markdown }) => ({ text: markdown, parse_mode: 'MarkdownV2' }),
+    Tgx: ({ tgx }) => ({ text: Tgx.html(tgx), parse_mode: 'HTML' }),
+  }),
+  Match.exhaustive,
+)
+
+type ParamsCaption = PickMethodParams<'sendPhoto', 'caption' | 'caption_entities' | 'parse_mode'>
+const paramsCaption = (caption: Option.Option<Text.Text>): ParamsCaption => (
+  Option.match(caption, {
+    onNone: () => ({}),
+    onSome: (caption) => {
+      const { text, entities, parse_mode } = paramsText(caption)
+      return { caption: text, caption_entities: entities, parse_mode }
+    },
+  })
+)
+
+type ParamsContentText = PickMethodParams<'sendMessage', 'text' | 'entities' | 'parse_mode' | 'link_preview_options'>
+type ParamsContentPhoto = PickMethodParams<'sendPhoto', 'photo' | 'caption' | 'caption_entities' | 'parse_mode' | 'show_caption_above_media' | 'has_spoiler'>
+type ParamsContentAudio = PickMethodParams<'sendAudio', 'audio' | 'caption' | 'caption_entities' | 'parse_mode' | 'duration' | 'performer' | 'title' | 'thumbnail'>
+type ParamsContentDocument = PickMethodParams<'sendDocument', 'document' | 'thumbnail' | 'caption' | 'parse_mode' | 'caption_entities' | 'disable_content_type_detection'>
+type ParamsContentVideo = PickMethodParams<'sendVideo', 'video' | 'duration' | 'width' | 'height' | 'thumbnail' | 'cover' | 'start_timestamp' | 'show_caption_above_media' | 'has_spoiler' | 'supports_streaming'>
+type ParamsContentAnimation = PickMethodParams<'sendAnimation', 'animation' | 'duration' | 'width' | 'height' | 'thumbnail' | 'has_spoiler'>
+type ParamsContentVoice = PickMethodParams<'sendVoice', 'voice' | 'duration'>
+type ParamsContentVideoNote = PickMethodParams<'sendVideoNote', 'video_note' | 'duration' | 'length' | 'thumbnail'>
+type ParamsContentLocation = PickMethodParams<'sendLocation', 'latitude' | 'longitude' | 'horizontal_accuracy' | 'live_period' | 'heading' | 'proximity_alert_radius'>
+type ParamsContentVenue = PickMethodParams<'sendVenue', 'latitude' | 'longitude' | 'title' | 'address' | 'foursquare_id' | 'foursquare_type' | 'google_place_id' | 'google_place_type'>
+type ParamsContentContact = PickMethodParams<'sendContact', 'phone_number' | 'first_name' | 'last_name' | 'vcard'>
+type ParamsContentDice = PickMethodParams<'sendDice', 'emoji'>
+type ParamsContentSticker = PickMethodParams<'sendSticker', 'sticker' | 'emoji'>
+const paramsContent: {
+  (content: Content.Text): ParamsContentText
+  (content: Content.Photo): ParamsContentPhoto
+  (content: Content.Audio): ParamsContentAudio
+  (content: Content.Document): ParamsContentDocument
+  (content: Content.Video): ParamsContentVideo
+  (content: Content.Animation): ParamsContentAnimation
+  (content: Content.Voice): ParamsContentVoice
+  (content: Content.VideoNote): ParamsContentVideoNote
+  (content: Content.Location): ParamsContentLocation
+  (content: Content.Venue): ParamsContentVenue
+  (content: Content.Contact): ParamsContentContact
+  (content: Content.Dice): ParamsContentDice
+  (content: Content.Sticker): ParamsContentSticker
+} = Function.pipe(
+  Match.type<Content.Content>(),
+  Match.tags({
+    Text: ({ text, linkPreview }): ParamsContentText => ({
+      ...paramsText(text),
+      link_preview_options: Option.match(linkPreview, {
+        onNone: () => ({ is_disabled: true }),
+        onSome: linkPreview => LinkPreview.options(linkPreview),
+      }),
+    }),
+    Photo: ({ file, caption, layout, spoiler }): ParamsContentPhoto => ({
+      ...paramsCaption(caption),
+      photo: file instanceof URL ? file.toString() : file,
+      show_caption_above_media: layout === 'caption-above',
+      has_spoiler: spoiler,
+    }),
+    Audio: ({ file, caption, duration, performer, title, thumbnail }): ParamsContentAudio => ({
+      ...paramsCaption(caption),
+      audio: file instanceof URL ? file.toString() : file,
+      duration: Option.match(duration, {
+        onNone: () => undefined,
+        onSome: duration => Math.round(Duration.toSeconds(duration)),
+      }),
+      performer: Option.getOrUndefined(performer),
+      title: Option.getOrUndefined(title),
+      thumbnail: Option.getOrUndefined(thumbnail),
+    }),
+    Document: ({ file, caption, thumbnail, contentTypeDetection }): ParamsContentDocument => ({
+      ...paramsCaption(caption),
+      document: file instanceof URL ? file.toString() : file,
+      thumbnail: Option.getOrUndefined(thumbnail),
+      disable_content_type_detection: !contentTypeDetection,
+    }),
+    Video: ({ file, caption, layout, spoiler, duration, width, height, thumbnail, cover, startAt, supportsStreaming }): ParamsContentVideo => ({
+      ...paramsCaption(caption),
+      video: file instanceof URL ? file.toString() : file,
+      duration: Option.match(duration, {
+        onNone: () => undefined,
+        onSome: duration => Math.round(Duration.toSeconds(duration)),
+      }),
+      width: Option.getOrUndefined(width),
+      height: Option.getOrUndefined(height),
+      thumbnail: Option.getOrUndefined(thumbnail),
+      cover: Option.map(cover, c => c instanceof URL ? c.toString() : c).pipe(Option.getOrUndefined),
+      start_timestamp: Option.match(startAt, {
+        onNone: () => undefined,
+        onSome: startAt => Math.round(Duration.toSeconds(startAt)),
+      }),
+      show_caption_above_media: layout === 'caption-above',
+      has_spoiler: spoiler,
+      supports_streaming: supportsStreaming,
+    }),
+    Animation: ({ file, caption, spoiler, duration, width, height, thumbnail }): ParamsContentAnimation => ({
+      ...paramsCaption(caption),
+      animation: file instanceof URL ? file.toString() : file,
+      duration: Option.match(duration, {
+        onNone: () => undefined,
+        onSome: duration => Math.round(Duration.toSeconds(duration)),
+      }),
+      width: Option.getOrUndefined(width),
+      height: Option.getOrUndefined(height),
+      thumbnail: Option.getOrUndefined(thumbnail),
+      has_spoiler: spoiler,
+    }),
+    Voice: ({ file, caption, duration }): ParamsContentVoice => ({
+      ...paramsCaption(caption),
+      voice: file instanceof URL ? file.toString() : file,
+      duration: Option.match(duration, {
+        onNone: () => undefined,
+        onSome: duration => Math.round(Duration.toSeconds(duration)),
+      }),
+    }),
+    VideoNote: ({ file, duration, diameter, thumbnail }): ParamsContentVideoNote => ({
+      video_note: file,
+      duration: Option.match(duration, {
+        onNone: () => undefined,
+        onSome: duration => Math.round(Duration.toSeconds(duration)),
+      }),
+      length: Option.getOrUndefined(diameter),
+      thumbnail: Option.getOrUndefined(thumbnail),
+    }),
+    Location: ({ latitude, longitude, uncertaintyRadius, livePeriod, heading, proximityAlertRadius }): ParamsContentLocation => ({
+      latitude,
+      longitude,
+      horizontal_accuracy: Option.getOrUndefined(uncertaintyRadius),
+      live_period: Option.match(livePeriod, {
+        onNone: () => undefined,
+        onSome: livePeriod => Duration.isFinite(livePeriod)
+          ? Math.round(Duration.toSeconds(livePeriod))
+          : 0x7FFFFFFF,
+      }),
+      heading: Option.getOrUndefined(heading),
+      proximity_alert_radius: Option.getOrUndefined(proximityAlertRadius),
+    }),
+    Venue: ({ latitude, longitude, title, address, foursquareId, foursquareType, googlePlaceId, googlePlaceType }): ParamsContentVenue => ({
+      latitude,
+      longitude,
+      title,
+      address,
+      foursquare_id: Option.getOrUndefined(foursquareId),
+      foursquare_type: Option.getOrUndefined(foursquareType),
+      google_place_id: Option.getOrUndefined(googlePlaceId),
+      google_place_type: Option.getOrUndefined(googlePlaceType),
+    }),
+    Contact: ({ phoneNumber, firstName, lastName, vcard }): ParamsContentContact => ({
+      phone_number: phoneNumber,
+      first_name: firstName,
+      last_name: Option.getOrUndefined(lastName),
+      vcard: Option.getOrUndefined(vcard),
+    }),
+    Dice: ({ emoji }): ParamsContentDice => ({
+      emoji,
+    }),
+    Sticker: ({ file, emoji }): ParamsContentSticker => ({
+      sticker: file instanceof URL ? file.toString() : file,
+      emoji: Option.getOrUndefined(emoji),
+    }),
+  }),
+  Match.exhaustive,
+) as any
+
+type ParamsDialog = PickMethodParams<SendMethod, 'chat_id' | 'message_thread_id' | 'direct_messages_topic_id'>
+const paramsDialog: (dialog: Dialog.Dialog) => ParamsDialog = Function.pipe(
+  Match.type<Dialog.Dialog>(),
+  Match.withReturnType<ParamsDialog>(),
+  Match.tagsExhaustive({
+    UserId: ({ dialogId }) => ({ chat_id: dialogId }),
+    GroupId: ({ dialogId }) => ({ chat_id: dialogId }),
+    ChannelId: ({ dialogId }) => ({ chat_id: dialogId }),
+    SupergroupId: ({ dialogId }) => ({ chat_id: dialogId }),
+    PublicChannel: ({ username }) => ({ chat_id: username }),
+    PublicSupergroup: ({ username }) => ({ chat_id: username }),
+    ForumTopic: ({ forum, topicId }) => ({
+      chat_id: Match.value(forum).pipe(
+        Match.tagsExhaustive({
+          SupergroupId: ({ dialogId }) => dialogId,
+          PublicSupergroup: ({ username }) => username,
+        }),
+      ),
+      message_thread_id: topicId,
+    }),
+    ChannelDm: ({ channel, userId }) => ({
+      chat_id: Match.value(channel).pipe(
+        Match.tagsExhaustive({
+          ChannelId: ({ dialogId }) => dialogId,
+          PublicChannel: ({ username }) => username,
+        }),
+      ),
+      direct_messages_topic_id: userId,
+    }),
+  }),
+)
+
+type ParamsOptions = PickMethodParams<SendMethod, 'disable_notification' | 'protect_content' | 'allow_paid_broadcast'>
+const paramsOptions = (options: Send.Options): ParamsOptions => {
+  return {
+    disable_notification: options.disableNotification || undefined,
+    protect_content: options.protectContent || undefined,
+    allow_paid_broadcast: options.allowPaidBroadcast || undefined,
+  }
+}
+
+type ParamsMarkup = PickMethodParams<SendMethod, 'reply_markup'>
+const paramsMarkup: (markup: Markup.Markup) => ParamsMarkup = Function.pipe(
+  Match.type<Markup.Markup>(),
+  Match.withReturnType<ParamsMarkup>(),
+  Match.tagsExhaustive({
+    InlineKeyboard: markup => ({
+      reply_markup: {
+        inline_keyboard: markup.rows, // TODO
+      },
+    }),
+    ReplyKeyboard: markup => ({
+      reply_markup: {
+        keyboard: markup.rows, // TODO
+        is_persistent: markup.persistent,
+        resize_keyboard: markup.resizable,
+        one_time_keyboard: markup.oneTime,
+        input_field_placeholder: Option.getOrUndefined(markup.inputPlaceholder),
+        selective: markup.selective,
+      },
+    }),
+    ReplyKeyboardRemove: markup => ({
+      reply_markup: {
+        remove_keyboard: true,
+        selective: markup.selective,
+      },
+    }),
+    ForceReply: markup => ({
+      reply_markup: {
+        force_reply: true,
+        input_field_placeholder: Option.getOrUndefined(markup.inputPlaceholder),
+        selective: markup.selective,
+      },
+    }),
+  }),
+)
+
+type PickMethodParams<
+  TMethod extends keyof BotApi.MethodParams,
+  TPick extends keyof BotApi.MethodParams[TMethod],
+> = Pick<BotApi.MethodParams[TMethod], TPick>
+
+type SendMethod = Extract<
+  keyof BotApi.MethodParams,
+  | 'sendMessage'
+  | 'sendPhoto'
+  | 'sendAudio'
+  | 'sendDocument'
+  | 'sendVideo'
+  | 'sendAnimation'
+  | 'sendVoice'
+  | 'sendVideoNote'
+  | 'sendPaidMedia'
+  | 'sendLocation'
+  | 'sendVenue'
+  | 'sendContact'
+  | 'sendDice'
+  | 'sendSticker'
+  | 'sendInvoice'
+>
+
+export const sendMessage = Effect.fnUntraced(function* (params: {
+  content: Content.Content
+  dialog: Dialog_.Dialog
+  options?: Send.Options
+  markup?: Markup.Markup
+}) {
+  const api = yield* BotApi.BotApi
+  const common = {
+    ...paramsDialog(params.dialog),
+    ...(params.options ? paramsOptions(params.options) : {}),
+    ...(params.markup ? paramsMarkup(params.markup) : {}),
+  }
+  return yield* Match.value(params.content).pipe(
+    Match.tagsExhaustive({
+      Text: content => api.sendMessage({ ...common, ...paramsContent(content) }),
+      Photo: content => api.sendPhoto({ ...common, ...paramsContent(content) }),
+      Audio: content => api.sendAudio({ ...common, ...paramsContent(content) }),
+      Document: content => api.sendDocument({ ...common, ...paramsContent(content) }),
+      Video: content => api.sendVideo({ ...common, ...paramsContent(content) }),
+      Animation: content => api.sendAnimation({ ...common, ...paramsContent(content) }),
+      Voice: content => api.sendVoice({ ...common, ...paramsContent(content) }),
+      VideoNote: content => api.sendVideoNote({ ...common, ...paramsContent(content) }),
+      Location: content => api.sendLocation({ ...common, ...paramsContent(content) }),
+      Venue: content => api.sendVenue({ ...common, ...paramsContent(content) }),
+      Contact: content => api.sendContact({ ...common, ...paramsContent(content) }),
+      Dice: content => api.sendDice({ ...common, ...paramsContent(content) }),
+      Sticker: content => api.sendSticker({ ...common, ...paramsContent(content) }),
+    }),
+  )
+})

package/dist/BotApiWebhook.d.ts

@@ -1,41 +0,0 @@
-/**
- * This module implements Telegram Bot API webhook requests verification.
- *
- * @see https://core.telegram.org/bots/api#setwebhook
- */
-import type * as HttpServerError from '@effect/platform/HttpServerError';
-import type * as BotApi from './BotApi.ts';
-import * as HttpApiMiddleware from '@effect/platform/HttpApiMiddleware';
-import * as $Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Redacted from 'effect/Redacted';
-import * as Schema from 'effect/Schema';
-export declare const SECRET_HEADER = "x-telegram-bot-api-secret-token";
-declare const VerificationFailedError_base: Schema.TaggedErrorClass<VerificationFailedError, "@grom.js/effect-tg/BotApiWebhook/VerificationFailedError", {
-    readonly _tag: Schema.tag<"@grom.js/effect-tg/BotApiWebhook/VerificationFailedError">;
-}>;
-export declare class VerificationFailedError extends VerificationFailedError_base {
-}
-declare const Context_base: $Context.TagClass<Context, "@grom.js/effect-tg/BotApiWebhook/Context", {
-    update: Effect.Effect<BotApi.Types.Update, HttpServerError.RequestError>;
-}>;
-export declare class Context extends Context_base {
-}
-declare const VerifyMiddleware_base: HttpApiMiddleware.TagClass.Base<VerifyMiddleware, "@grom.js/effect-tg/BotApiWebhook/VerifyMiddleware", {
-    readonly optional: false;
-    readonly failure: typeof VerificationFailedError;
-    readonly provides: typeof Context;
-}, HttpApiMiddleware.HttpApiMiddleware<{
-    update: Effect.Effect<BotApi.Types.Update, HttpServerError.RequestError>;
-}, VerificationFailedError>>;
-export declare class VerifyMiddleware extends VerifyMiddleware_base {
-    static layer(options: {
-        /**
-         * Telegram webhook secret token.
-         */
-        secret: Redacted.Redacted<string>;
-    }): Layer.Layer<VerifyMiddleware, never, never>;
-}
-export {};
-//# sourceMappingURL=BotApiWebhook.d.ts.map

package/dist/BotApiWebhook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BotApiWebhook.d.ts","sourceRoot":"","sources":["../src/BotApiWebhook.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,KAAK,eAAe,MAAM,kCAAkC,CAAA;AACxE,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,iBAAiB,MAAM,oCAAoC,CAAA;AAGvE,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,eAAO,MAAM,aAAa,oCAAoC,CAAA;;;;AAG9D,qBAAa,uBAAwB,SAAQ,4BAO5C;CAAG;;YAIQ,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,YAAY,CAAC;;AAF5E,qBAAa,OAAQ,SAAQ,YAG1B;CAAG;;;;;;YADM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,YAAY,CAAC;;AAG5E,qBAAa,gBAAiB,SAAQ,qBAOrC;WACe,KAAK,CAAC,OAAO,EAAE;QAC3B;;WAEG;QACH,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;KAClC;CAkBF"}

package/dist/BotApiWebhook.js

@@ -1,43 +0,0 @@
-/**
- * This module implements Telegram Bot API webhook requests verification.
- *
- * @see https://core.telegram.org/bots/api#setwebhook
- */
-import * as HttpApiMiddleware from '@effect/platform/HttpApiMiddleware';
-import * as HttpApiSchema from '@effect/platform/HttpApiSchema';
-import * as HttpServerRequest from '@effect/platform/HttpServerRequest';
-import * as $Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Redacted from 'effect/Redacted';
-import * as Schema from 'effect/Schema';
-export const SECRET_HEADER = 'x-telegram-bot-api-secret-token';
-// eslint-disable-next-line unicorn/throw-new-error
-export class VerificationFailedError extends Schema.TaggedError()('@grom.js/effect-tg/BotApiWebhook/VerificationFailedError', {}, HttpApiSchema.annotations({
-    status: 401,
-    description: 'Missing or invalid webhook secret.',
-})) {
-}
-export class Context extends $Context.Tag('@grom.js/effect-tg/BotApiWebhook/Context')() {
-}
-export class VerifyMiddleware extends HttpApiMiddleware.Tag()('@grom.js/effect-tg/BotApiWebhook/VerifyMiddleware', {
-    optional: false,
-    failure: VerificationFailedError,
-    provides: Context,
-}) {
-    static layer(options) {
-        return Layer.succeed(VerifyMiddleware, Effect.gen(function* () {
-            const request = yield* HttpServerRequest.HttpServerRequest;
-            const actual = request.headers[SECRET_HEADER];
-            if (actual == null) {
-                return yield* new VerificationFailedError();
-            }
-            if (actual !== Redacted.value(options.secret)) {
-                return yield* new VerificationFailedError();
-            }
-            return {
-                update: Effect.map(request.json, update => update),
-            };
-        }));
-    }
-}

package/dist/Chat.d.ts

@@ -1,96 +0,0 @@
-import * as Data from 'effect/Data';
-export type Chat = PeerUser | PeerGroup | PeerChannel | PeerSupergroup | PublicChannel | PublicSupergroup | ForumTopic | ChannelDm;
-declare const PeerUser_base: new (options: {
-    id: number;
-}) => {
-    readonly id: number;
-    readonly dialogId: number;
-    sendParams: () => {
-        chat_id: number | string;
-        message_thread_id?: number | undefined;
-        direct_messages_topic_id?: number | undefined;
-    };
-};
-export declare class PeerUser extends PeerUser_base {
-}
-declare const PeerGroup_base: new (options: {
-    id: number;
-}) => {
-    readonly id: number;
-    readonly dialogId: number;
-    sendParams: () => {
-        chat_id: number | string;
-        message_thread_id?: number | undefined;
-        direct_messages_topic_id?: number | undefined;
-    };
-};
-export declare class PeerGroup extends PeerGroup_base {
-}
-declare const PeerChannel_base: new (options: {
-    id: number;
-}) => {
-    readonly id: number;
-    readonly dialogId: number;
-    sendParams: () => {
-        chat_id: number | string;
-        message_thread_id?: number | undefined;
-        direct_messages_topic_id?: number | undefined;
-    };
-};
-export declare class PeerChannel extends PeerChannel_base {
-}
-declare const PeerSupergroup_base: new (options: {
-    id: number;
-}) => {
-    readonly id: number;
-    readonly dialogId: number;
-    sendParams: () => {
-        chat_id: number | string;
-        message_thread_id?: number | undefined;
-        direct_messages_topic_id?: number | undefined;
-    };
-};
-export declare class PeerSupergroup extends PeerSupergroup_base {
-}
-export declare class PublicChannel extends Data.Class<{
-    username: string;
-}> {
-    sendParams(): {
-        chat_id: string;
-    };
-}
-export declare class PublicSupergroup extends Data.Class<{
-    username: string;
-}> {
-    sendParams(): {
-        chat_id: string;
-    };
-}
-export declare class ForumTopic extends Data.Class<{
-    forum: PeerSupergroup | PublicSupergroup;
-    topicId: number;
-}> {
-    sendParams(): {
-        message_thread_id: number;
-        chat_id: number | string;
-        direct_messages_topic_id?: number | undefined;
-    } | {
-        message_thread_id: number;
-        chat_id: string;
-    };
-}
-export declare class ChannelDm extends Data.Class<{
-    channel: PeerChannel | PublicChannel;
-    userId: number;
-}> {
-    sendParams(): {
-        direct_messages_topic_id: number;
-        chat_id: number | string;
-        message_thread_id?: number | undefined;
-    } | {
-        direct_messages_topic_id: number;
-        chat_id: string;
-    };
-}
-export {};
-//# sourceMappingURL=Chat.d.ts.map

package/dist/Chat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../src/Chat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AAGnC,MAAM,MAAM,IAAI,GACV,QAAQ,GACR,SAAS,GACT,WAAW,GACX,cAAc,GACd,aAAa,GACb,gBAAgB,GAChB,UAAU,GACV,SAAS,CAAA;;;;;;;;;;;;AAEf,qBAAa,QAAS,SAAQ,aAG5B;CAAG;;;;;;;;;;;;AAEL,qBAAa,SAAU,SAAQ,cAG7B;CAAG;;;;;;;;;;;;AAEL,qBAAa,WAAY,SAAQ,gBAG/B;CAAG;;;;;;;;;;;;AAEL,qBAAa,cAAe,SAAQ,mBAGlC;CAAG;AAEL,qBAAa,aAAc,SAAQ,IAAI,CAAC,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;IACjE,UAAU;;;CAGX;AAED,qBAAa,gBAAiB,SAAQ,IAAI,CAAC,KAAK,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;IACpE,UAAU;;;CAGX;AAED,qBAAa,UAAW,SAAQ,IAAI,CAAC,KAAK,CAAC;IACzC,KAAK,EAAE,cAAc,GAAG,gBAAgB,CAAA;IACxC,OAAO,EAAE,MAAM,CAAA;CAChB,CAAC;IACA,UAAU;;;;;;;;CAMX;AAED,qBAAa,SAAU,SAAQ,IAAI,CAAC,KAAK,CAAC;IACxC,OAAO,EAAE,WAAW,GAAG,aAAa,CAAA;IACpC,MAAM,EAAE,MAAM,CAAA;CACf,CAAC;IACA,UAAU;;;;;;;;CAMX"}

package/dist/Chat.js

@@ -1,48 +0,0 @@
-import * as Data from 'effect/Data';
-import * as internal from "./internal/chat.js";
-export class PeerUser extends internal.Peer({
-    validatePeerId: id => (id >= 1 && id <= 0xFFFFFFFFFF),
-    peerIdToDialogId: id => id,
-}) {
-}
-export class PeerGroup extends internal.Peer({
-    validatePeerId: id => (id >= 1 && id <= 999999999999),
-    peerIdToDialogId: id => -id,
-}) {
-}
-export class PeerChannel extends internal.Peer({
-    validatePeerId: id => (id >= 1 && id <= 997852516352),
-    peerIdToDialogId: id => -(1000000000000 + id),
-}) {
-}
-export class PeerSupergroup extends internal.Peer({
-    validatePeerId: id => (id >= 1 && id <= 997852516352),
-    peerIdToDialogId: id => -(1000000000000 + id),
-}) {
-}
-export class PublicChannel extends Data.Class {
-    sendParams() {
-        return { chat_id: this.username };
-    }
-}
-export class PublicSupergroup extends Data.Class {
-    sendParams() {
-        return { chat_id: this.username };
-    }
-}
-export class ForumTopic extends Data.Class {
-    sendParams() {
-        return {
-            ...this.forum.sendParams(),
-            message_thread_id: this.topicId,
-        };
-    }
-}
-export class ChannelDm extends Data.Class {
-    sendParams() {
-        return {
-            ...this.channel.sendParams(),
-            direct_messages_topic_id: this.userId,
-        };
-    }
-}

package/dist/InputFile.d.ts

@@ -1,4 +0,0 @@
-/** @todo */
-export declare class InputFile {
-}
-//# sourceMappingURL=InputFile.d.ts.map

package/dist/InputFile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InputFile.d.ts","sourceRoot":"","sources":["../src/InputFile.ts"],"names":[],"mappings":"AAAA,YAAY;AACZ,qBAAa,SAAS;CAAG"}

package/dist/InputFile.js

@@ -1,3 +0,0 @@
-/** @todo */
-export class InputFile {
-}

package/dist/internal/botApiMethod.d.ts

@@ -1,8 +0,0 @@
-import type { Effect } from 'effect/Effect';
-import type { BotApiError } from '../BotApi.ts';
-import type { BotApiTransportError } from '../BotApiTransport.ts';
-import type { MethodParams, MethodResults } from './botApiMethods.gen.ts';
-export interface BotApiMethod<M extends keyof MethodParams> {
-    (params: MethodParams[M]): Effect<MethodResults[M], BotApiError | BotApiTransportError>;
-}
-//# sourceMappingURL=botApiMethod.d.ts.map

package/dist/internal/botApiMethod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"botApiMethod.d.ts","sourceRoot":"","sources":["../../src/internal/botApiMethod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAEzE,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,MAAM,YAAY;IACxD,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,CAC/B,aAAa,CAAC,CAAC,CAAC,EAChB,WAAW,GAAG,oBAAoB,CACnC,CAAA;CACF"}

package/dist/internal/botApiMethod.js

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