@mtcute/core 0.29.6 → 0.30.0

package/highlevel/updates/manager.js

@@ -14,6 +14,178 @@ import { RpcError } from "../../tl/inner-tl.js";
 const WARN_EVERY = 100;
 const KEEP_ALIVE_INTERVAL = 15 * 60 * 1e3;
 const UPDATES_TOO_LONG = { _: "updatesTooLong" };
+function collectRichTextPeerIds(text, peers) {
+  if (!text) return;
+  switch (text._) {
+    case "textEmpty":
+    case "textPlain":
+    case "textEmail":
+    case "textPhone":
+    case "textImage":
+    case "textMath":
+    case "textCustomEmoji":
+      break;
+    case "textBold":
+    case "textItalic":
+    case "textUnderline":
+    case "textStrike":
+    case "textFixed":
+    case "textUrl":
+    case "textSubscript":
+    case "textSuperscript":
+    case "textMarked":
+    case "textAnchor":
+    case "textSpoiler":
+    case "textMention":
+    case "textHashtag":
+    case "textBotCommand":
+    case "textCashtag":
+    case "textAutoUrl":
+    case "textAutoEmail":
+    case "textAutoPhone":
+    case "textBankCard":
+    case "textDate":
+      collectRichTextPeerIds(text.text, peers);
+      break;
+    case "textConcat":
+      for (const child of text.texts) collectRichTextPeerIds(child, peers);
+      break;
+    case "textMentionName":
+      peers.add(text.userId);
+      collectRichTextPeerIds(text.text, peers);
+      break;
+    default:
+      assertNever();
+  }
+}
+function collectPageCaptionPeerIds(caption, peers) {
+  if (!caption) return;
+  collectRichTextPeerIds(caption.text, peers);
+  collectRichTextPeerIds(caption.credit, peers);
+}
+function collectPageBlockPeerIds(block, peers) {
+  if (!block) return;
+  switch (block._) {
+    case "pageBlockUnsupported":
+    case "pageBlockDivider":
+    case "pageBlockAnchor":
+    case "pageBlockMath":
+      break;
+    case "pageBlockTitle":
+    case "pageBlockSubtitle":
+    case "pageBlockHeader":
+    case "pageBlockSubheader":
+    case "pageBlockParagraph":
+    case "pageBlockPreformatted":
+    case "pageBlockFooter":
+    case "pageBlockKicker":
+    case "pageBlockThinking":
+    case "pageBlockHeading1":
+    case "pageBlockHeading2":
+    case "pageBlockHeading3":
+    case "pageBlockHeading4":
+    case "pageBlockHeading5":
+    case "pageBlockHeading6":
+      collectRichTextPeerIds(block.text, peers);
+      break;
+    case "pageBlockAuthorDate":
+      collectRichTextPeerIds(block.author, peers);
+      break;
+    case "pageBlockList":
+      for (const item of block.items) collectPageListItemPeerIds(item, peers);
+      break;
+    case "pageBlockOrderedList":
+      for (const item of block.items) collectPageListOrderedItemPeerIds(item, peers);
+      break;
+    case "pageBlockBlockquote":
+    case "pageBlockPullquote":
+      collectRichTextPeerIds(block.text, peers);
+      collectRichTextPeerIds(block.caption, peers);
+      break;
+    case "pageBlockPhoto":
+    case "pageBlockVideo":
+    case "pageBlockEmbed":
+    case "pageBlockAudio":
+    case "pageBlockMap":
+    case "inputPageBlockMap":
+      collectPageCaptionPeerIds(block.caption, peers);
+      break;
+    case "pageBlockCover":
+      collectPageBlockPeerIds(block.cover, peers);
+      break;
+    case "pageBlockEmbedPost":
+      for (const child of block.blocks) collectPageBlockPeerIds(child, peers);
+      collectPageCaptionPeerIds(block.caption, peers);
+      break;
+    case "pageBlockCollage":
+    case "pageBlockSlideshow":
+      for (const child of block.items) collectPageBlockPeerIds(child, peers);
+      collectPageCaptionPeerIds(block.caption, peers);
+      break;
+    case "pageBlockChannel":
+      switch (block.channel._) {
+        case "chatEmpty":
+        case "chat":
+        case "chatForbidden":
+          peers.add(getMarkedPeerId(block.channel.id, "chat"));
+          break;
+        case "channel":
+        case "channelForbidden":
+          peers.add(getMarkedPeerId(block.channel.id, "channel"));
+          break;
+        default:
+          assertNever(block.channel);
+      }
+      break;
+    case "pageBlockTable":
+      collectRichTextPeerIds(block.title, peers);
+      for (const row of block.rows) {
+        for (const cell of row.cells) collectRichTextPeerIds(cell.text, peers);
+      }
+      break;
+    case "pageBlockDetails":
+      for (const child of block.blocks) collectPageBlockPeerIds(child, peers);
+      collectRichTextPeerIds(block.title, peers);
+      break;
+    case "pageBlockRelatedArticles":
+      collectRichTextPeerIds(block.title, peers);
+      break;
+    case "pageBlockBlockquoteBlocks":
+      for (const child of block.blocks) collectPageBlockPeerIds(child, peers);
+      collectRichTextPeerIds(block.caption, peers);
+      break;
+    default:
+      assertNever();
+  }
+}
+function collectPageListItemPeerIds(item, peers) {
+  switch (item._) {
+    case "pageListItemText":
+      collectRichTextPeerIds(item.text, peers);
+      break;
+    case "pageListItemBlocks":
+      for (const block of item.blocks) collectPageBlockPeerIds(block, peers);
+      break;
+    default:
+      assertNever();
+  }
+}
+function collectPageListOrderedItemPeerIds(item, peers) {
+  switch (item._) {
+    case "pageListOrderedItemText":
+      collectRichTextPeerIds(item.text, peers);
+      break;
+    case "pageListOrderedItemBlocks":
+      for (const block of item.blocks) collectPageBlockPeerIds(block, peers);
+      break;
+    default:
+      assertNever();
+  }
+}
+function collectRichMessagePeerIds(richMessage, peers) {
+  if (!richMessage) return;
+  for (const block of richMessage.blocks) collectPageBlockPeerIds(block, peers);
+}
 class UpdatesManager {
   constructor(client, params = {}) {
     this.client = client;
@@ -86,6 +258,9 @@ class UpdatesManager {
   cptsMod = /* @__PURE__ */ new Map();
   channelDiffTimeouts = /* @__PURE__ */ new Map();
   channelsOpened = /* @__PURE__ */ new Map();
+  // channels we got CHANNEL_PRIVATE for when fetching diff — skip gap handling.
+  // invalidated when an updateChannel for that channel arrives
+  inaccessibleChannels = /* @__PURE__ */ new Set();
   log;
   _onCatchingUp = () => {
   };
@@ -107,6 +282,7 @@ class UpdatesManager {
     this.stopLoop();
     this.cpts.clear();
     this.cptsMod.clear();
+    this.inaccessibleChannels.clear();
     this.pts = this.qts = this.date = this.seq = void 0;
   }
   async prepare() {
@@ -482,6 +658,7 @@ class UpdatesManager {
             return missing;
           }
           if (!await fetchPeer(msg.viaBotId)) return missing;
+          if (!await fetchPeer(msg.guestchatViaFrom)) return missing;
           if (msg.entities) {
             for (const ent of msg.entities) {
               if (ent._ === "messageEntityMentionName") {
@@ -489,6 +666,13 @@ class UpdatesManager {
               }
             }
           }
+          if (msg.richMessage) {
+            const richMessagePeers = /* @__PURE__ */ new Set();
+            collectRichMessagePeerIds(msg.richMessage, richMessagePeers);
+            for (const peer of richMessagePeers) {
+              if (!await fetchPeer(peer)) return missing;
+            }
+          }
           if (msg.media) {
             switch (msg.media._) {
               case "messageMediaContact":
@@ -538,6 +722,13 @@ class UpdatesManager {
             }
           }
         }
+        if ("richMessage" in upd.draft && upd.draft.richMessage) {
+          const richMessagePeers = /* @__PURE__ */ new Set();
+          collectRichMessagePeerIds(upd.draft.richMessage, richMessagePeers);
+          for (const peer of richMessagePeers) {
+            if (!await fetchPeer(peer)) return missing;
+          }
+        }
     }
     return missing;
   }
@@ -560,7 +751,13 @@ class UpdatesManager {
     store(msg.fromId);
     if (msg._ === "message") {
       store(msg.viaBotId);
+      store(msg.guestchatViaFrom);
       store(msg.fwdFrom?.fromId);
+      if (msg.richMessage) {
+        const richMessagePeers = /* @__PURE__ */ new Set();
+        collectRichMessagePeerIds(msg.richMessage, richMessagePeers);
+        store([...richMessagePeers]);
+      }
       if (msg.media) {
         switch (msg.media._) {
           case "messageMediaWebPage":
@@ -725,14 +922,20 @@ class UpdatesManager {
         channelId,
         this._fetchChannelDifference(channelId, fallbackPts).catch((err) => {
           this.log.warn("error fetching difference for %d: %e", channelId, err);
-          if (RpcError.is("PERSISTENT_TIMESTAMP_INVALID")) {
+          if (RpcError.is(err, "PERSISTENT_TIMESTAMP_INVALID")) {
             this.log.warn("received PERSISTENT_TIMESTAMP_INVALID, resetting channel pts value");
             this.cpts.delete(channelId);
             this.cptsMod.delete(channelId);
           }
+          if (RpcError.is(err, "CHANNEL_PRIVATE") || RpcError.is(err, "CHANNEL_INVALID")) {
+            this.log.debug("channel %d is inaccessible, skipping gap fills until updateChannel", channelId);
+            this.inaccessibleChannels.add(channelId);
+            this.cpts.delete(channelId);
+            this.cptsMod.delete(channelId);
+          }
         }).then((ok) => {
           requestedDiff.delete(channelId);
-          if (!ok) {
+          if (!ok && !this.inaccessibleChannels.has(channelId)) {
             this.log.debug("channel difference for %d failed, falling back to common diff", channelId);
             this._fetchDifferenceLater(requestedDiff);
           }
@@ -933,6 +1136,13 @@ class UpdatesManager {
         }
         break;
       }
+      case "updateChannel": {
+        const channel = pending.peers.chat(upd.channelId);
+        if (channel._ !== "channelForbidden") {
+          this.inaccessibleChannels.delete(upd.channelId);
+        }
+        break;
+      }
       case "updateConfig":
         client.mt.network.config.update(true).catch((err) => client.onError.emit(unknownToError(err)));
         break;
@@ -1250,7 +1460,8 @@ class UpdatesManager {
               );
               continue;
             }
-            if (diff < 0) {
+            const isInaccessibleChannel = pending.channelId && this.inaccessibleChannels.has(pending.channelId);
+            if (diff < 0 && !isInaccessibleChannel) {
               if (diff > -3) {
                 log.debug(
                   "postponing %s for 0.5s (cid = %d) because small gap detected (by pts: exp %d, got %d, diff=%d)",

package/highlevel/utils/inspectable.cjs

@@ -50,4 +50,5 @@ function makeInspectable(obj, props, hide) {
   obj.prototype[customInspectSymbol] = obj.prototype.toJSON;
   return obj;
 }
+exports.customInspectSymbol = customInspectSymbol;
 exports.makeInspectable = makeInspectable;

package/highlevel/utils/inspectable.d.cts

@@ -1,3 +1,4 @@
+export declare const customInspectSymbol: symbol;
 /**
  * Small helper function that adds `toJSON` and `util.custom.inspect`
  * methods to a given class based on its getters

package/highlevel/utils/inspectable.d.ts

@@ -1,3 +1,4 @@
+export declare const customInspectSymbol: symbol;
 /**
  * Small helper function that adds `toJSON` and `util.custom.inspect`
  * methods to a given class based on its getters

package/highlevel/utils/inspectable.js

@@ -44,5 +44,6 @@ function makeInspectable(obj, props, hide) {
   return obj;
 }
 export {
+  customInspectSymbol,
   makeInspectable
 };

package/index.cjs

@@ -56,6 +56,7 @@ const messageReactions = require("./highlevel/types/messages/message-reactions.c
 const messageReplies = require("./highlevel/types/messages/message-replies.cjs");
 const message = require("./highlevel/types/messages/message.cjs");
 const repliedMessage = require("./highlevel/types/messages/replied-message.cjs");
+const richMessage = require("./highlevel/types/messages/rich-message.cjs");
 const searchFilters = require("./highlevel/types/messages/search-filters.cjs");
 const suggestedPost = require("./highlevel/types/messages/suggested-post.cjs");
 const collectibleInfo = require("./highlevel/types/misc/collectible-info.cjs");
@@ -118,6 +119,7 @@ const storyInteractions = require("./highlevel/types/stories/story-interactions.
 const storyViewer = require("./highlevel/types/stories/story-viewer.cjs");
 const story$1 = require("./highlevel/types/stories/story.cjs");
 const botChatJoinRequest = require("./highlevel/types/updates/bot-chat-join-request.cjs");
+const botGuestChatQuery = require("./highlevel/types/updates/bot-guest-chat-query.cjs");
 const botReaction = require("./highlevel/types/updates/bot-reaction.cjs");
 const botStopped = require("./highlevel/types/updates/bot-stopped.cjs");
 const callbackQuery = require("./highlevel/types/updates/callback-query.cjs");
@@ -224,6 +226,7 @@ exports.MessageReactions = messageReactions.MessageReactions;
 exports.MessageRepliesInfo = messageReplies.MessageRepliesInfo;
 exports.Message = message.Message;
 exports.RepliedMessageInfo = repliedMessage.RepliedMessageInfo;
+exports.RichMessage = richMessage.RichMessage;
 exports.SearchFilters = searchFilters.SearchFilters;
 exports.SuggestedPostInfo = suggestedPost.SuggestedPostInfo;
 exports.CollectibleInfo = collectibleInfo.CollectibleInfo;
@@ -297,6 +300,7 @@ exports.StoryViewer = storyViewer.StoryViewer;
 exports.StoryViewersList = storyViewer.StoryViewersList;
 exports.Story = story$1.Story;
 exports.BotChatJoinRequestUpdate = botChatJoinRequest.BotChatJoinRequestUpdate;
+exports.BotGuestChatQuery = botGuestChatQuery.BotGuestChatQuery;
 exports.BotReactionCountUpdate = botReaction.BotReactionCountUpdate;
 exports.BotReactionUpdate = botReaction.BotReactionUpdate;
 exports.BotStoppedUpdate = botStopped.BotStoppedUpdate;

package/index.js

@@ -49,6 +49,7 @@ import { MessageReactions } from "./highlevel/types/messages/message-reactions.j
 import { MessageRepliesInfo } from "./highlevel/types/messages/message-replies.js";
 import { Message } from "./highlevel/types/messages/message.js";
 import { RepliedMessageInfo } from "./highlevel/types/messages/replied-message.js";
+import { RichMessage } from "./highlevel/types/messages/rich-message.js";
 import { SearchFilters } from "./highlevel/types/messages/search-filters.js";
 import { SuggestedPostInfo } from "./highlevel/types/messages/suggested-post.js";
 import { CollectibleInfo } from "./highlevel/types/misc/collectible-info.js";
@@ -111,6 +112,7 @@ import { StoryInteractions } from "./highlevel/types/stories/story-interactions.
 import { StoryRepost, StoryViewer, StoryViewersList } from "./highlevel/types/stories/story-viewer.js";
 import { Story } from "./highlevel/types/stories/story.js";
 import { BotChatJoinRequestUpdate } from "./highlevel/types/updates/bot-chat-join-request.js";
+import { BotGuestChatQuery } from "./highlevel/types/updates/bot-guest-chat-query.js";
 import { BotReactionCountUpdate, BotReactionUpdate } from "./highlevel/types/updates/bot-reaction.js";
 import { BotStoppedUpdate } from "./highlevel/types/updates/bot-stopped.js";
 import { BusinessCallbackQuery, CallbackQuery, InlineCallbackQuery } from "./highlevel/types/updates/callback-query.js";
@@ -163,6 +165,7 @@ export {
   BoostStats,
   BotChatJoinRequestUpdate,
   inner as BotCommands,
+  BotGuestChatQuery,
   BotInfo,
   factories$1 as BotInline,
   factories as BotInlineMessage,
@@ -269,6 +272,7 @@ export {
   RawUpdateInfo,
   ReactionCount,
   RepliedMessageInfo,
+  RichMessage,
   SavedStarGift,
   SearchFilters,
   SentCode,

package/methods.cjs

@@ -18,6 +18,7 @@ const signIn = require("./highlevel/methods/auth/sign-in.cjs");
 const startTest = require("./highlevel/methods/auth/start-test.cjs");
 const start = require("./highlevel/methods/auth/start.cjs");
 const utils = require("./highlevel/methods/auth/utils.cjs");
+const answerBotGuestChatQuery = require("./highlevel/methods/bots/answer-bot-guest-chat-query.cjs");
 const answerCallbackQuery = require("./highlevel/methods/bots/answer-callback-query.cjs");
 const answerInlineQuery = require("./highlevel/methods/bots/answer-inline-query.cjs");
 const answerPreCheckoutQuery = require("./highlevel/methods/bots/answer-pre-checkout-query.cjs");
@@ -299,6 +300,7 @@ exports.signIn = signIn.signIn;
 exports.startTest = startTest.startTest;
 exports.start = start.start;
 exports.isSelfPeer = utils.isSelfPeer;
+exports.answerBotGuestChatQuery = answerBotGuestChatQuery.answerBotGuestChatQuery;
 exports.answerCallbackQuery = answerCallbackQuery.answerCallbackQuery;
 exports.answerInlineQuery = answerInlineQuery.answerInlineQuery;
 exports.answerPreCheckoutQuery = answerPreCheckoutQuery.answerPreCheckoutQuery;

package/methods.js

@@ -11,6 +11,7 @@ import { signIn } from "./highlevel/methods/auth/sign-in.js";
 import { startTest } from "./highlevel/methods/auth/start-test.js";
 import { start } from "./highlevel/methods/auth/start.js";
 import { isSelfPeer } from "./highlevel/methods/auth/utils.js";
+import { answerBotGuestChatQuery } from "./highlevel/methods/bots/answer-bot-guest-chat-query.js";
 import { answerCallbackQuery } from "./highlevel/methods/bots/answer-callback-query.js";
 import { answerInlineQuery } from "./highlevel/methods/bots/answer-inline-query.js";
 import { answerPreCheckoutQuery } from "./highlevel/methods/bots/answer-pre-checkout-query.js";
@@ -289,6 +290,7 @@ export {
   addChatMembers,
   addContact,
   addStickerToSet,
+  answerBotGuestChatQuery,
   answerCallbackQuery,
   answerInlineQuery,
   answerMedia,

package/network/flood-control.cjs

@@ -0,0 +1,149 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+class FloodControl {
+  _rules;
+  _maxWindow;
+  _events = [];
+  constructor(rules) {
+    if (rules.length === 0) throw new Error("FloodControl needs at least one rule");
+    this._rules = rules;
+    this._maxWindow = rules.reduce((m, r) => Math.max(m, r.windowMs), 0);
+  }
+  /** Earliest absolute perf-now ms at which a new event is permitted. */
+  getWakeupAt(now) {
+    let wakeup = 0;
+    for (const { count, windowMs } of this._rules) {
+      const cutoff = now - windowMs;
+      let inWindow = 0;
+      let oldestInWindowIdx = -1;
+      for (let i = this._events.length - 1; i >= 0; i--) {
+        if (this._events[i] <= cutoff) break;
+        inWindow++;
+        oldestInWindowIdx = i;
+      }
+      if (inWindow >= count) {
+        const t = this._events[oldestInWindowIdx] + windowMs;
+        if (t > wakeup) wakeup = t;
+      }
+    }
+    return wakeup;
+  }
+  addEvent(now) {
+    this._events.push(now);
+    this._prune(now);
+  }
+  _prune(now) {
+    const cutoff = now - this._maxWindow;
+    let i = 0;
+    while (i < this._events.length && this._events[i] < cutoff) i++;
+    if (i > 0) this._events.splice(0, i);
+  }
+  reset() {
+    this._events = [];
+  }
+}
+const DEFAULT_SANITY_LIMITS = [
+  { count: 5, windowMs: 1e4 }
+];
+const DEFAULT_FLOOD_LIMITS = [
+  { count: 1, windowMs: 1e3 },
+  { count: 4, windowMs: 2e3 },
+  { count: 8, windowMs: 3e3 }
+];
+const DEFAULT_MTPROTO_ERROR_LIMITS = [
+  { count: 1, windowMs: 1e3 },
+  { count: 4, windowMs: 2e3 },
+  { count: 8, windowMs: 3e3 }
+];
+class ConnectionFloodController {
+  sanity;
+  flood;
+  mtprotoError;
+  _log;
+  constructor(limits = {}) {
+    this.sanity = new FloodControl(limits.sanity ?? DEFAULT_SANITY_LIMITS);
+    this.flood = new FloodControl(limits.flood ?? DEFAULT_FLOOD_LIMITS);
+    this.mtprotoError = new FloodControl(limits.mtprotoError ?? DEFAULT_MTPROTO_ERROR_LIMITS);
+  }
+  setLogger(log) {
+    this._log = log;
+  }
+  /**
+   * Notify a network-up transition.
+   *
+   * TDLib clears sanity + online-regime flood + backoff on
+   * `ConnectionCreator::on_network(true)`. We don't model the online regime,
+   * and our transport layer owns its own reconnect backoff, so only the
+   * sanity limiter is reset here.
+   */
+  notifyNetworkUp() {
+    this._log?.debug("network up, resetting sanity limiter");
+    this.sanity.reset();
+  }
+  /** Record an MTProto-level error (transport 429; per TDLib, other codes don't tick this). */
+  addMtprotoError(now = performance.now()) {
+    this._log?.debug("recording mtproto error");
+    this.mtprotoError.addEvent(now);
+  }
+  /** Earliest perf-now ms at which a new connection attempt is permitted. */
+  getWakeupAt(now) {
+    return Math.max(
+      this.sanity.getWakeupAt(now),
+      this.flood.getWakeupAt(now),
+      this.mtprotoError.getWakeupAt(now)
+    );
+  }
+  /**
+   * Block until a connection attempt is permitted under all applicable
+   * limiters, then record the attempt. Concurrent waiters serialize fairly
+   * because the first to wake records its event before the next checks state.
+   *
+   * If `signal` aborts, the pending timer is cleared and the promise rejects
+   * with the signal's reason.
+   */
+  async wait(signal) {
+    let waited = false;
+    while (true) {
+      signal?.throwIfAborted();
+      const now = performance.now();
+      const wakeup = this.getWakeupAt(now);
+      if (wakeup <= now) {
+        this.sanity.addEvent(now);
+        this.flood.addEvent(now);
+        if (waited) this._log?.debug("admitted connect after waiting");
+        return;
+      }
+      const delay = wakeup - now;
+      this._log?.debug("connect throttled (waiting %dms)", Math.round(delay));
+      waited = true;
+      await new Promise((resolve, reject) => {
+        const handle = utils.timers.setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          resolve();
+        }, delay);
+        const onAbort = () => {
+          utils.timers.clearTimeout(handle);
+          reject(signal.reason);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+      });
+    }
+  }
+  /** Reset all internal state. Mainly for tests. */
+  reset() {
+    this.sanity.reset();
+    this.flood.reset();
+    this.mtprotoError.reset();
+  }
+}
+exports.ConnectionFloodController = ConnectionFloodController;
+exports.DEFAULT_FLOOD_LIMITS = DEFAULT_FLOOD_LIMITS;
+exports.DEFAULT_MTPROTO_ERROR_LIMITS = DEFAULT_MTPROTO_ERROR_LIMITS;
+exports.DEFAULT_SANITY_LIMITS = DEFAULT_SANITY_LIMITS;
+exports.FloodControl = FloodControl;

package/network/flood-control.d.cts

@@ -0,0 +1,79 @@
+import { Logger } from '../utils/logger.js';
+export interface FloodLimit {
+    /** maximum events allowed within `windowMs` */
+    count: number;
+    /** window size in ms */
+    windowMs: number;
+}
+/**
+ * Sliding-window flood control. Port of TDLib's `FloodControlStrict`
+ * (tdutils/td/utils/FloodControlStrict.h).
+ */
+export declare class FloodControl {
+    private readonly _rules;
+    private readonly _maxWindow;
+    private _events;
+    constructor(rules: readonly FloodLimit[]);
+    /** Earliest absolute perf-now ms at which a new event is permitted. */
+    getWakeupAt(now: number): number;
+    addEvent(now: number): void;
+    private _prune;
+    reset(): void;
+}
+export declare const DEFAULT_SANITY_LIMITS: readonly FloodLimit[];
+export declare const DEFAULT_FLOOD_LIMITS: readonly FloodLimit[];
+export declare const DEFAULT_MTPROTO_ERROR_LIMITS: readonly FloodLimit[];
+export interface ConnectionFloodLimits {
+    sanity?: readonly FloodLimit[];
+    flood?: readonly FloodLimit[];
+    mtprotoError?: readonly FloodLimit[];
+}
+/**
+ * Per-connection-slot flood control bundle modeled after TDLib's
+ * `ConnectionCreator` client state (`ConnectionCreator.cpp`) — TDLib keys
+ * its flood control by pool slot (the `SessionProxy#i` hash), so each
+ * socket's connect history is throttled independently.
+ *
+ * Three limiters compose:
+ *  - `sanity` — absolute ceiling, always applied
+ *  - `flood` — burst limit on connection attempts, always applied
+ *  - `mtprotoError` — ticks only on MTProto-level errors, always applied
+ *
+ * TDLib additionally has a stricter "online" regime keyed to app foreground
+ * state — we have no such signal, so only the permissive regime is modeled.
+ *
+ * `wait()` blocks until all limiters allow a fresh connection and records
+ * the event atomically (sanity + flood).
+ */
+export declare class ConnectionFloodController {
+    readonly sanity: FloodControl;
+    readonly flood: FloodControl;
+    readonly mtprotoError: FloodControl;
+    private _log?;
+    constructor(limits?: ConnectionFloodLimits);
+    setLogger(log: Logger): void;
+    /**
+     * Notify a network-up transition.
+     *
+     * TDLib clears sanity + online-regime flood + backoff on
+     * `ConnectionCreator::on_network(true)`. We don't model the online regime,
+     * and our transport layer owns its own reconnect backoff, so only the
+     * sanity limiter is reset here.
+     */
+    notifyNetworkUp(): void;
+    /** Record an MTProto-level error (transport 429; per TDLib, other codes don't tick this). */
+    addMtprotoError(now?: number): void;
+    /** Earliest perf-now ms at which a new connection attempt is permitted. */
+    getWakeupAt(now: number): number;
+    /**
+     * Block until a connection attempt is permitted under all applicable
+     * limiters, then record the attempt. Concurrent waiters serialize fairly
+     * because the first to wake records its event before the next checks state.
+     *
+     * If `signal` aborts, the pending timer is cleared and the promise rejects
+     * with the signal's reason.
+     */
+    wait(signal?: AbortSignal): Promise<void>;
+    /** Reset all internal state. Mainly for tests. */
+    reset(): void;
+}