fix: correct Telegram update/keyboard models and harden env parsing

Implemented full tgapi method coverage from Telegram docs, aligned numeric ID/file_size types, and fixed method signatures/JSON tags.; Standardized GoDoc across exported APIs with Telegram links and refreshed README sections for MsgContext plus API/Uploader usage.

.gitignore

@@ -0,0 +1,2 @@
+.idea/
+test/

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

Makefile

@@ -0,0 +1,15 @@
+# Проверка наличия golangci-lint
+GO_LINT := $(shell command -v golangci-lint 2>/dev/null)
+
+# Цель: запуск всех проверок кода
+check:
+	@echo "🔍 Running code checks..."
+	@go mod tidy -v
+	@go vet ./...
+	@if [ -n "$(GO_LINT)" ]; then \
+		echo "✅ golangci-lint found, running..." && \
+		golangci-lint run --timeout=5m --verbose; \
+	else \
+		echo "⚠️  golangci-lint not installed. Install with: curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.57.2"; \
+	fi
+	@go test -race -v ./... 2>/dev/null || echo "⚠️  Tests skipped or failed (run manually with 'go test -race ./...')"

README.md

@@ -0,0 +1,218 @@
+# Laniakea
+
+[![Go Version](https://img.shields.io/badge/Go-1.24+-00ADD8?logo=go&style=flat-square)](https://go.dev/)
+[![License: GPL-3.0](https://img.shields.io/badge/License-GPL%203.0-blue.svg?style=flat-square)](LICENSE)
+![Gitea Release](https://img.shields.io/gitea/v/release/ScuroNeko/Laniakea?gitea_url=https%3A%2F%2Fgit.nix13.pw&sort=semver&display_name=release&style=flat-square&color=purple&link=https%3A%2F%2Fgit.nix13.pw%2FScuroNeko%2FLaniakea%2Freleases)
+
+A lightweight, easy-to-use, and performant Telegram Bot API wrapper for Go. It simplifies bot development with a clean plugin system, middleware support, automatic command generation, and built-in rate limiting.
+
+[На русском](README_RU.md)
+
+---
+
+## ✨ Features
+*   **Simple & Intuitive API:** Designed for ease of use, based on practical examples.
+*   **Plugin System:** Organize your bot's functionality into independent, reusable plugins.
+*   **Command Handling:** Easily register commands and extract arguments.
+*   **Middleware Support:** Run code before or after commands (e.g., logging, access control).
+*   **Automatic Command Generation:** Generate help and command lists automatically.
+*   **Built-in Rate Limiting:** Protect your bot from hitting Telegram API limits (supports `retry_after` handling).
+*   **Context-Aware:** Pass custom database or state contexts to your handlers.
+*   **Fluent Interface:** Chain methods for clean configuration (e.g., `bot.ErrorTemplate(...).AddPlugins(...)`).
+
+---
+
+## 📦 Installation
+
+```bash
+go get git.nix13.pw/scuroneko/laniakea
+```
+
+## 🚀 Quick Start (with step-by-step explanation)
+
+Here is a minimal echo/ping bot example with detailed comments.
+```go
+package main
+
+import (
+	"log"
+
+	"git.nix13.pw/scuroneko/laniakea" // Import the Laniakea library
+)
+
+// echo is a command handler function.
+// It receives two parameters:
+//   - ctx: the message context (contains info about the message, sender, chat, etc.)
+//   - db: your custom database context (here we use NoDB, a placeholder for no database)
+func echo(ctx *laniakea.MsgContext, db *laniakea.NoDB) {
+	// Answer the user with the text they sent, without any command prefix.
+	// ctx.Text contains the user's message with the command part stripped off.
+	ctx.Answer(ctx.Text) // User input WITHOUT command
+}
+
+func main() {
+	// 1. Create bot options. Replace "TOKEN" with your actual bot token from @BotFather.
+	opts := &laniakea.BotOpts{Token: "TOKEN"}
+
+	// 2. Initialize a new bot instance.
+	//    We use laniakea.NoDB as the database context type (no database needed for this example).
+	bot := laniakea.NewBot[laniakea.NoDB](opts)
+	// Ensure bot resources are cleaned up on exit.
+	defer bot.Close()
+
+	// 3. Create a new plugin named "ping".
+	//    Plugins help group related commands and middlewares.
+	p := laniakea.NewPlugin[laniakea.NoDB]("ping")
+
+	// 4. Add a command to the plugin.
+	//    p.NewCommand(echo, "echo") creates a command that triggers the 'echo' function on the "/echo" command.
+	p.AddCommand(p.NewCommand(echo, "echo"))
+
+	// 5. Add another command using an anonymous function (closure).
+	//    This command simply replies "Pong" when the user sends "/ping".
+	p.AddCommand(p.NewCommand(func(ctx *laniakea.MsgContext, db *laniakea.NoDB) {
+		ctx.Answer("Pong")
+	}, "ping"))
+
+	// 6. Configure the bot with a custom error template and add the plugin.
+	//    ErrorTemplate sets a format string for errors (where %s will be replaced by the actual error).
+	//    AddPlugins(p) registers our "ping" plugin with the bot.
+	bot = bot.ErrorTemplate("Error\n\n%s").AddPlugins(p)
+
+	// 7. Automatically generate commands like /start, /help, and a list of all registered commands.
+	//    This is optional but very useful for most bots.
+	if err := bot.AutoGenerateCommands(); err != nil {
+		log.Println(err)
+	}
+
+	// 8. Start the bot, listening for updates (long polling).
+	bot.Run()
+}
+```
+
+### How It Works
+1. `BotOpts`: Holds configuration like the API token.
+2. `NewBot[T]`: Creates a bot instance. The type parameter T allows you to pass a custom database context (e.g., *sql.DB) that will be available in all handlers. Use laniakea.NoDB if you don't need it.
+3. `NewPlugin`: Creates a logical group for commands and middlewares.
+4. `AddCommand`: Registers a command. The first argument is the handler function (func(*MsgContext, T)), the second is the command name (without the slash).
+5. **Handler Functions**: Receive *MsgContext (message details, methods like Answer) and your custom database context T.
+6. `ErrorTemplate`: Sets a template for error messages. The %s placeholder is replaced by the actual error.
+7. `AutoGenerateCommands`: Adds built-in commands (/start, /help) and a command that lists all available commands.
+8. `Run()`: Starts the bot's update polling loop.
+
+## 📖 Core Concepts
+### Plugins
+
+Plugins are the main way to organize code. A plugin can have multiple commands and middlewares.
+```go
+plugin := laniakea.NewPlugin[MyDB]("admin")
+plugin.AddCommand(plugin.NewCommand(banUser, "ban"))
+bot.AddPlugins(plugin)
+```
+
+### Commands
+
+A command is a function that handles a specific bot command (e.g., /start).
+```go
+func myHandler(ctx *laniakea.MsgContext, db *MyDB) {
+    // Access command arguments via ctx.Args ([]string)
+    // Reply to the user: ctx.Answer("some text")
+}
+```
+
+### MsgContext
+
+Provides access to the incoming message and useful reply methods:
+
+- `Answer(text string) *AnswerMessage`: Sends a message with parse_mode none.
+- `AnswerMarkdown(text string) *AnswerMessage`: Sends a message formatted with MarkdownV2 (you handle escaping).
+- `Keyboard(text string, keyboard *InlineKeyboard) *AnswerMessage`: Sends a message with parse_mode none and inline keyboard.
+- `KeyboardMarkdown(text string, keyboard *InlineKeyboard) *AnswerMessage`: Sends a message formatted with MarkdownV2 (you handle escaping) and inline keyboard.
+- `AnswerPhoto(photoId, text string) *AnswerMessage`: Sends a message with photo with parse_mode none.
+- `AnswerPhotoMarkdown(photoId, text string) *AnswerMessage`: Sends a photo with MarkdownV2 caption (you handle escaping).
+- `EditCallback(text string)`: Edits message with parse_mode none after clicking inline button.
+- `EditCallbackMarkdown(text string)`: Edits a message formatted with MarkdownV2 (you handle escaping) after clicking inline button.
+- `SendAction(action tgapi.ChatActionType)`: Sends a “typing”, “uploading photo”, etc., action.
+- Fields: `Text`, `Args`, `From`, `FromID`, `Msg`, `InlineMsgId`, `CallbackQueryId`, etc.
+- And more methods and fields!
+
+### tgapi: API and Uploader
+
+`tgapi` provides two clients:
+
+- `API` for JSON requests (e.g., `SendMessage`, `EditMessageText`, methods using file_id/URL).
+- `Uploader` for multipart uploads (e.g., `SendPhoto`, `SendDocument`, `SendVideo` with binary files).
+
+This split keeps method intent explicit: JSON-only calls go through `API`, file uploads go through `Uploader`.
+
+### Database Context
+
+The `T` in `NewBot[T]` is a powerful feature. You can pass any type (like a database connection pool), and it will be available in every command and middleware handler.
+
+```go
+type MyDB struct { /* ... */ }
+db := &MyDB{...}
+bot := laniakea.NewBot[*MyDB](opts, db) // Pass db instance
+```
+
+## 🧩 Middleware
+Middleware are functions that run before a command handler. They are perfect for cross-cutting concerns like logging, access control, rate limiting, or modifying the context.
+
+### Signature
+A middleware function has the same signature as a command handler, but it must return a bool:
+
+```go
+func(ctx *MsgContext, db T) bool
+```
+
+- If it returns true, the next middleware (or the command) will be executed.
+- If it returns false, the execution chain stops immediately (the command will not run).
+
+### Adding Middleware
+Use the Use method of a plugin to add one or more middleware functions. They are executed in the order they are added.
+
+```go
+plugin := laniakea.NewPlugin[MyDB]("admin")
+plugin.Use(loggingMiddleware, adminOnlyMiddleware)
+plugin.AddCommand(plugin.NewCommand(banUser, "ban"))
+```
+
+### Example Middlewares
+
+1. Logging Middleware – logs every command execution.
+```go
+func loggingMiddleware(ctx *laniakea.MsgContext, db *MyDB) bool {
+    log.Printf("User %d executed command: %s", ctx.FromID, ctx.Msg.Text)
+    return true // continue to next middleware/command
+}
+```
+
+2. Admin-Only Middleware – restricts access to users with a specific role.
+```go
+func adminOnlyMiddleware(ctx *laniakea.MsgContext, db *MyDB) bool {
+    if !db.IsAdmin(ctx.FromID) { // assume db has IsAdmin method
+        ctx.Answer("⛔ Access denied. Admins only.")
+        return false // stop execution
+    }
+    return true
+}
+```
+
+### Important Notes
+- Middleware can modify the MsgContext (e.g., add custom fields) before the command runs.
+
+## ⚙️ Advanced Configuration
+- **Inline Keyboards**: Build keyboards using `laniakea.NewInlineKeyboardJson`, `laniakea.NewInlineKeyboardBase64`, or `laniakea.NewInlineKeyboard`.
+- **Rate Limiting**: Pass a configured utils.RateLimiter via BotOpts to handle Telegram's rate limits gracefully.
+- **Custom HTTP Client**: Provide your own http.Client in BotOpts for fine-tuned control.
+
+## 📝 License
+
+This project is licensed under the GNU General Public License v3.0 — see the [LICENSE](LICENSE) file for details.
+
+## 📚 Learn More
+[GoDoc](https://pkg.go.dev/git.nix13.pw/scuroneko/laniakea)
+
+[Telegram Bot API](https://core.telegram.org/bots/api)
+
+    ✅ Built with ❤️ by scuroneko

README_RU.md

@@ -0,0 +1,207 @@
+# Laniakea
+
+[![Go Version](https://img.shields.io/badge/Go-1.24+-00ADD8?logo=go&style=flat-square)](https://go.dev/)
+[![License: GPL-3.0](https://img.shields.io/badge/License-GPL%203.0-blue.svg?style=flat-square)](LICENSE)
+![Gitea Release](https://img.shields.io/gitea/v/release/ScuroNeko/Laniakea?gitea_url=https%3A%2F%2Fgit.nix13.pw&sort=semver&display_name=release&style=flat-square&color=purple&link=https%3A%2F%2Fgit.nix13.pw%2FScuroNeko%2FLaniakea%2Freleases)
+
+Легковесная, простая в использовании и производительная обёртка для Telegram Bot API на Go. Она упрощает разработку ботов благодаря чистой системе плагинов, поддержке中间件, автоматической генерации команд и встроенному ограничителю скорости запросов.
+
+[English](README.md)
+
+---
+
+## ✨ Возможности
+
+*   **Простой и интуитивный API:** Разработан для лёгкости использования, основан на практических примерах.
+*   **Система плагинов:** Организуйте функциональность бота в независимые, переиспользуемые плагины.
+*   **Обработка команд:** Легко регистрируйте команды и извлекайте аргументы.
+*   **Поддержка промежуточных слоёв (Middleware):** Выполняйте код до или после команд (например, логирование, проверка доступа).
+*   **Автоматическая генерация команд:** Генерируйте справку и списки команд автоматически.
+*   **Встроенный ограничитель запросов (Rate Limiter):** Защитите бота от превышения лимитов Telegram API (с обработкой `retry_after`).
+*   **Контекст данных:** Передавайте свой контекст базы данных или состояния в обработчики.
+*   **Текучий интерфейс (Fluent Interface):** Стройте цепочки методов для чистой конфигурации (например, `bot.ErrorTemplate(...).AddPlugins(...)`).
+
+---
+
+## 📦 Установка
+
+```bash
+go get git.nix13.pw/scuroneko/laniakea
+```
+
+## 🚀 Быстрый старт (с пошаговыми комментариями)
+Вот минимальный пример бота "echo/ping" с подробными комментариями.
+
+```go
+package main
+
+import (
+	"log"
+
+	"git.nix13.pw/scuroneko/laniakea" // Импортируем библиотеку Laniakea
+)
+
+// echo — это функция-обработчик команды.
+// Она получает два параметра:
+//   - ctx: контекст сообщения (содержит информацию о сообщении, отправителе, чате и т.д.)
+//   - db: ваш пользовательский контекст базы данных (здесь мы используем NoDB — заглушку)
+func echo(ctx *laniakea.MsgContext, db *laniakea.NoDB) {
+	// Отвечаем пользователю текстом, который он прислал, без префикса команды.
+	// ctx.Text содержит сообщение пользователя, из которого удалена часть с командой.
+	ctx.Answer(ctx.Text) // Ввод пользователя БЕЗ команды
+}
+
+func main() {
+	// 1. Создаём опции бота. Замените "TOKEN" на реальный токен от @BotFather.
+	opts := &laniakea.BotOpts{Token: "TOKEN"}
+
+	// 2. Инициализируем новый экземпляр бота.
+	//    Используем laniakea.NoDB как тип контекста базы данных (база не нужна для примера).
+	bot := laniakea.NewBot[laniakea.NoDB](opts)
+	// Гарантируем освобождение ресурсов бота при выходе.
+	defer bot.Close()
+
+	// 3. Создаём новый плагин с именем "ping".
+	//    Плагины помогают группировать связанные команды и промежуточные обработчики.
+	p := laniakea.NewPlugin[laniakea.NoDB]("ping")
+
+	// 4. Добавляем команду в плагин.
+	//    p.NewCommand(echo, "echo") создаёт команду, которая вызывает функцию 'echo' по команде "/echo".
+	p.AddCommand(p.NewCommand(echo, "echo"))
+
+	// 5. Добавляем ещё одну команду, используя анонимную функцию (замыкание).
+	//    Эта команда просто отвечает "Pong", когда пользователь отправляет "/ping".
+	p.AddCommand(p.NewCommand(func(ctx *laniakea.MsgContext, db *laniakea.NoDB) {
+		ctx.Answer("Pong")
+	}, "ping"))
+
+	// 6. Настраиваем бота: задаём шаблон ошибки и добавляем плагин.
+	//    ErrorTemplate устанавливает формат для сообщений об ошибках (где %s будет заменён на текст ошибки).
+	//    AddPlugins(p) регистрирует наш плагин "ping" в боте.
+	bot = bot.ErrorTemplate("Ошибка\n\n%s").AddPlugins(p)
+
+	// 7. Автоматически генерируем команды, такие как /start, /help и список всех зарегистрированных команд.
+	//    Это необязательно, но очень полезно для большинства ботов.
+	if err := bot.AutoGenerateCommands(); err != nil {
+		log.Println(err)
+	}
+
+	// 8. Запускаем бота, начиная прослушивание обновлений (long polling).
+	bot.Run()
+}
+```
+
+### Как это работает
+1. `BotOpts`: Содержит конфигурацию, например, токен API.
+2. `NewBot[T]`: Создаёт экземпляр бота. Параметр типа T позволяет передать пользовательский контекст базы данных (например, *sql.DB), который будет доступен во всех обработчиках. Используйте laniakea.NoDB, если он не нужен.
+3. `NewPlugin`: Создаёт логическую группу для команд и Middleware.
+4. `AddCommand`: Регистрирует команду. Первый аргумент — функция-обработчик (func(*MsgContext, T)), второй — имя команды (без слеша).
+5. **Функции-обработчики**: Получают *MsgContext (детали сообщения, методы типа Answer) и ваш контекст базы данных T.
+6. `ErrorTemplate`: Устанавливает шаблон для сообщений об ошибках. Плейсхолдер %s заменяется на текст ошибки.
+7. `AutoGenerateCommands`: Добавляет встроенные команды (/start, /help) и команду, показывающую список всех доступных команд.
+8. `Run()`: Запускает цикл опроса обновлений бота.
+
+## 📖 Основные концепции
+### Плагины (Plugins)
+Плагины — основной способ организации кода. Плагин может содержать несколько команд и Middleware.
+
+```go
+plugin := laniakea.NewPlugin[MyDB]("admin")
+plugin.AddCommand(plugin.NewCommand(banUser, "ban"))
+bot.AddPlugins(plugin)
+```
+
+### Команды (Commands)
+Команда — это функция, которая обрабатывает конкретную команду бота (например, /start).
+
+```go
+func myHandler(ctx *laniakea.MsgContext, db *MyDB) {
+    // Доступ к аргументам команды через ctx.Args ([]string)
+    // Ответ пользователю: ctx.Answer("какой-то текст")
+}
+```
+
+### Контекст сообщения (MsgContext)
+Предоставляет доступ к входящему сообщению и полезные методы для ответа:
+
+- `Answer(text string)`: Отправляет сообщение с parse_mode none.
+- `AnswerMarkdown(text string)`: Отправляет сообщение, отформатированное MarkdownV2 (экранирование на вашей стороне).
+- `Keyboard(text string, keyboard *InlineKeyboard) *AnswerMessage`: Отправляет сообщение с parse_mode none и Inline клавиатурой.
+- `KeyboardMarkdown(text string, keyboard *InlineKeyboard) *AnswerMessage`: Отправляет сообщение, отформатированное MarkdownV2 (экранирование на вашей стороне), и Inline клавиатурой.
+- `AnswerPhoto(photoId, text string) *AnswerMessage`: Отправляет фотографию с подписью и parse_mode none.
+- `AnswerPhotoMarkdown(photoId, text string) *AnswerMessage`: Отправляет фотографию с подписью, отформатированной MarkdownV2 (экранирование на вашей стороне).
+- `EditCallback(text string)`: Редактирует сообщение, форматируя его в MarkdownV2 (экранирование на вашей стороне), после нажатия Inline кнопки.
+- `EditCallbackMarkdown(text string)`: Редактирует сообщение с parse_mode none после нажатия Inline кнопки.
+- `SendChatAction(action string)`: Отправляет действие "печатает", "загружает фото" и т.д.
+- Поля: `Text`, `Args`, `From`, `Chat`, `Msg` и другие.
+- И много других методов и полей!
+
+### Контекст базы данных (Database Context)
+Параметр типа `T` в `NewBot[T]` — мощная функция. Вы можете передать любой тип (например, пул соединений с БД), и он будет доступен в каждом обработчике команды и中间件.
+
+```go
+type MyDB struct { /* ... */ }
+db := &MyDB{...}
+bot := laniakea.NewBot[*MyDB](opts, db) // Передаём экземпляр db
+```
+
+## 🧩 Промежуточные слои (Middleware)
+Middleware — это функции, которые выполняются перед обработчиком команды. Они идеально подходят для сквозных задач, таких как логирование, контроль доступа, ограничение скорости запросов или модификация контекста.
+
+### Сигнатура
+Функция middleware имеет ту же сигнатуру, что и обработчик команды, но должна возвращать bool:
+
+```go
+func(ctx *MsgContext, db T) bool
+```
+
+- Если возвращается true, выполняется следующий middleware (или сама команда).
+- Если возвращается false, цепочка выполнения немедленно прерывается (команда не запускается).
+
+### Добавление middleware
+Используйте метод Use плагина для добавления одной или нескольких функций middleware. Они выполняются в порядке добавления.
+
+```go
+plugin := laniakea.NewPlugin[MyDB]("admin")
+plugin.Use(loggingMiddleware, adminOnlyMiddleware)
+plugin.AddCommand(plugin.NewCommand(banUser, "ban"))
+```
+
+### Примеры middleware
+
+1. Логирующий middleware – логирует каждое выполнение команды.
+```go
+func loggingMiddleware(ctx *laniakea.MsgContext, db *MyDB) bool {
+    log.Printf("Пользователь %d выполнил команду: %s", ctx.FromID, ctx.Msg.Text)
+    return true // продолжаем к следующему middleware/команде
+}
+```
+
+2. Middleware только для администраторов – ограничивает доступ пользователям с определённой ролью.
+```go
+func adminOnlyMiddleware(ctx *laniakea.MsgContext, db *MyDB) bool {
+    if !db.IsAdmin(ctx.FromID) { // предполагается, что db имеет метод IsAdmin
+        ctx.Answer("⛔ Доступ запрещён. Только для администраторов.")
+        return false // останавливаем выполнение
+    }
+    return true
+}
+```
+
+### Важные замечания
+- Middleware может изменять MsgContext (например, добавлять пользовательские поля) перед запуском команды.
+
+## ⚙️ Расширенная настройка
+**Инлайн-клавиатуры**: Создавайте клавиатуры с помощью laniakea.NewKeyboard().
+**Ограничение запросов**: Передайте настроенный utils.RateLimiter через BotOpts для корректной обработки лимитов Telegram.
+**Пользовательский HTTP-клиент**: Предоставьте свой http.Client в BotOpts для точного контроля.
+
+## 📝 Лицензия
+Этот проект лицензирован под GNU General Public License v3.0 - подробности см. в файле [LICENSE](LICENSE).
+
+## 📚 Дополнительная информация
+[GoDoc Laniakea](https://pkg.go.dev/git.nix13.pw/scuroneko/laniakea)
+
+[Telegram Bot API](https://core.telegram.org/bots/api)
+
+    ✅ Создано с ❤️ scuroneko

bot.go

@@ -0,0 +1,551 @@
+package laniakea
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"git.nix13.pw/scuroneko/extypes"
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+	"git.nix13.pw/scuroneko/laniakea/utils"
+	"git.nix13.pw/scuroneko/slog"
+	"github.com/alitto/pond/v2"
+)
+
+// DbContext is an interface representing the application's database context.
+// It is injected into plugins and middleware via Bot.DatabaseContext().
+//
+// Example:
+//
+//	type MyDB struct { ... }
+//	bot := NewBot[MyDB](opts).DatabaseContext(&myDB)
+//
+// Use NoDB if no database is needed.
+type DbContext any
+
+// NoDB is a placeholder type for bots that do not use a database.
+// Use Bot[NoDB] to indicate no dependency injection is required.
+type NoDB struct{ DbContext }
+
+// DbLogger is a function type that returns a slog.LoggerWriter for database logging.
+// Used to inject database-specific log output (e.g., SQL queries, ORM events).
+type DbLogger[T DbContext] func(db *T) slog.LoggerWriter
+
+// BotPayloadType defines the serialization format for callback data payloads.
+type BotPayloadType string
+
+var (
+	// BotPayloadBase64 encodes callback data as a Base64 string.
+	BotPayloadBase64 BotPayloadType = "base64"
+	// BotPayloadJson encodes callback data as a JSON string.
+	BotPayloadJson BotPayloadType = "json"
+)
+
+// Bot is the core Telegram bot instance.
+//
+// Manages:
+//   - API communication via tgapi
+//   - Update processing pipeline (middleware → plugins)
+//   - Background runners
+//   - Logging and rate limiting
+//   - Localization and draft message support
+//
+// All methods are safe for concurrent use. Direct field access is not recommended.
+type Bot[T DbContext] struct {
+	token         string
+	debug         bool
+	errorTemplate string
+	username      string
+	payloadType   BotPayloadType
+	maxWorkers    int
+
+	logger        *slog.Logger                // Main bot logger (JSON stdout + optional file)
+	RequestLogger *slog.Logger                // Optional request-level API logging
+	extraLoggers  extypes.Slice[*slog.Logger] // API, Uploader, and custom loggers
+
+	plugins     []Plugin[T]     // Command/event handlers
+	middlewares []Middleware[T] // Pre-processing filters (sorted by order)
+	prefixes    []string        // Command prefixes (e.g., "/", "!")
+	runners     []Runner[T]     // Background tasks (e.g., cleanup, cron)
+
+	api           *tgapi.API      // Telegram API client
+	uploader      *tgapi.Uploader // File uploader
+	dbContext     *T              // Injected database context
+	l10n          *L10n           // Localization manager
+	draftProvider *DraftProvider  // Draft message builder
+
+	updateOffsetMu sync.Mutex
+	updateOffset   int                // Last processed update ID
+	updateTypes    []tgapi.UpdateType // Types of updates to fetch
+	updateQueue    chan *tgapi.Update // Internal queue for processing updates
+	runnerOnceWG   sync.WaitGroup     // Tracks one-time async runners
+	runnerBgWG     sync.WaitGroup     // Tracks background async runners
+}
+
+// NewBot creates and initializes a new Bot instance using the provided BotOpts.
+//
+// Automatically:
+//   - Creates API and Uploader clients
+//   - Initializes structured logging (JSON stdout + optional file)
+//   - Fetches bot username via GetMe()
+//   - Sets up DraftProvider with random IDs
+//   - Adds API and Uploader loggers to extraLoggers
+//
+// Panics if:
+//   - Token is empty
+//   - GetMe() fails (invalid token or network error)
+func NewBot[T any](opts *BotOpts) *Bot[T] {
+	if opts.Token == "" {
+		panic("laniakea: BotOpts.Token is required")
+	}
+
+	updateQueue := make(chan *tgapi.Update, 512)
+
+	//var limiter *utils.RateLimiter
+	//if opts.RateLimit > 0 {
+	//	limiter = utils.NewRateLimiter()
+	//}
+	limiter := utils.NewRateLimiter()
+	limiter.SetGlobalRate(opts.RateLimit)
+
+	apiOpts := tgapi.NewAPIOpts(opts.Token).
+		SetAPIUrl(opts.APIUrl).
+		UseTestServer(opts.UseTestServer).
+		SetLimiter(limiter).
+		SetLimiterDrop(opts.DropRLOverflow)
+	api := tgapi.NewAPI(apiOpts)
+	uploader := tgapi.NewUploader(api)
+
+	prefixes := opts.Prefixes
+	if len(prefixes) == 0 {
+		prefixes = []string{"/"}
+	}
+
+	workers := 32
+	if opts.MaxWorkers > 0 {
+		workers = opts.MaxWorkers
+	}
+
+	bot := &Bot[T]{
+		updateOffset:  0,
+		errorTemplate: "%s",
+		payloadType:   BotPayloadBase64,
+		maxWorkers:    workers,
+		updateQueue:   updateQueue,
+		api:           api,
+		uploader:      uploader,
+		debug:         opts.Debug,
+		prefixes:      prefixes,
+		token:         opts.Token,
+		plugins:       make([]Plugin[T], 0),
+		updateTypes:   append([]tgapi.UpdateType{}, opts.UpdateTypes...),
+		runners:       make([]Runner[T], 0),
+		extraLoggers:  make([]*slog.Logger, 0),
+		l10n:          &L10n{},
+		draftProvider: NewRandomDraftProvider(api),
+	}
+
+	// Add API and Uploader loggers to extraLoggers for unified output
+	bot.extraLoggers = bot.extraLoggers.Push(api.GetLogger()).Push(uploader.GetLogger())
+
+	if len(opts.ErrorTemplate) > 0 {
+		bot.errorTemplate = opts.ErrorTemplate
+	}
+	if len(opts.LoggerBasePath) == 0 {
+		opts.LoggerBasePath = "./"
+	}
+	bot.initLoggers(opts)
+
+	// Fetch bot info to validate token and get username
+	u, err := api.GetMe()
+	if err != nil {
+		_ = bot.Close()
+		bot.logger.Fatal(err)
+	}
+	bot.username = Val(u.Username, "")
+	if bot.username == "" {
+		bot.logger.Warn("Can't get bot username. Named command handlers won't work!")
+	}
+	bot.logger.Infoln(fmt.Sprintf("Authorized as %s (@%s)", u.FirstName, Val(u.Username, "unknown")))
+
+	return bot
+}
+
+// Close gracefully shuts down the bot.
+//
+// Closes:
+//   - Uploader (waits for pending uploads)
+//   - API client
+//   - RequestLogger (if enabled)
+//   - Main logger
+//
+// Returns the first error encountered, if any.
+func (bot *Bot[T]) Close() error {
+	var firstErr error
+
+	if err := bot.uploader.Close(); err != nil {
+		bot.logger.Errorln(err)
+		if firstErr == nil {
+			firstErr = err
+		}
+	}
+	if err := bot.api.CloseApi(); err != nil {
+		bot.logger.Errorln(err)
+		if firstErr == nil {
+			firstErr = err
+		}
+	}
+	if bot.RequestLogger != nil {
+		if err := bot.RequestLogger.Close(); err != nil {
+			bot.logger.Errorln(err)
+			if firstErr == nil {
+				firstErr = err
+			}
+		}
+	}
+	if err := bot.logger.Close(); err != nil {
+		if firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}
+
+// initLoggers configures the main and optional request loggers.
+//
+// Uses DEBUG flag to set log level (DEBUG if true, FATAL otherwise).
+// Writes to stdout in JSON format by default.
+// If WriteToFile is true, writes to main.log and requests.log in LoggerBasePath.
+func (bot *Bot[T]) initLoggers(opts *BotOpts) {
+	level := slog.FATAL
+	if opts.Debug {
+		level = slog.DEBUG
+	}
+
+	bot.logger = slog.CreateLogger().Level(level).Prefix("BOT")
+	bot.logger.AddWriter(bot.logger.CreateJsonStdoutWriter())
+	if opts.WriteToFile {
+		path := fmt.Sprintf("%s/main.log", strings.TrimRight(opts.LoggerBasePath, "/"))
+		fileWriter, err := bot.logger.CreateTextFileWriter(path)
+		if err != nil {
+			bot.logger.Fatal(err)
+		}
+		bot.logger.AddWriter(fileWriter)
+	}
+
+	if opts.UseRequestLogger {
+		bot.RequestLogger = slog.CreateLogger().Level(level).Prefix("REQUESTS")
+		bot.RequestLogger.AddWriter(bot.RequestLogger.CreateJsonStdoutWriter())
+		if opts.WriteToFile {
+			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(opts.LoggerBasePath, "/"))
+			fileWriter, err := bot.RequestLogger.CreateTextFileWriter(path)
+			if err != nil {
+				bot.logger.Fatal(err)
+			}
+			bot.RequestLogger.AddWriter(fileWriter)
+		}
+	}
+}
+
+// GetUpdateOffset returns the current update offset (thread-safe).
+func (bot *Bot[T]) GetUpdateOffset() int {
+	bot.updateOffsetMu.Lock()
+	defer bot.updateOffsetMu.Unlock()
+	return bot.updateOffset
+}
+
+// SetUpdateOffset sets the update offset for next GetUpdates call (thread-safe).
+func (bot *Bot[T]) SetUpdateOffset(offset int) {
+	bot.updateOffsetMu.Lock()
+	defer bot.updateOffsetMu.Unlock()
+	bot.updateOffset = offset
+}
+
+// GetUpdateTypes returns the list of update types the bot is configured to receive.
+func (bot *Bot[T]) GetUpdateTypes() []tgapi.UpdateType { return bot.updateTypes }
+
+// GetLogger returns the main bot logger.
+func (bot *Bot[T]) GetLogger() *slog.Logger { return bot.logger }
+
+// GetDBContext returns the injected database context.
+// Returns nil if not set via DatabaseContext().
+func (bot *Bot[T]) GetDBContext() *T { return bot.dbContext }
+
+// L10n translates a key in the given language.
+// Returns empty string if translation not found.
+func (bot *Bot[T]) L10n(lang, key string) string {
+	return bot.l10n.Translate(lang, key)
+}
+
+// SetDraftProvider replaces the default DraftProvider with a custom one.
+// Useful for using LinearDraftIdGenerator to persist draft IDs across restarts.
+func (bot *Bot[T]) SetDraftProvider(p *DraftProvider) *Bot[T] {
+	bot.draftProvider = p
+	return bot
+}
+
+// DatabaseContext injects a database context into the bot.
+// This context is accessible to plugins and middleware via GetDBContext().
+func (bot *Bot[T]) DatabaseContext(ctx *T) *Bot[T] {
+	bot.dbContext = ctx
+	return bot
+}
+
+// UpdateTypes sets the list of update types the bot will request from Telegram.
+// Overwrites any previously set types.
+func (bot *Bot[T]) UpdateTypes(t ...tgapi.UpdateType) *Bot[T] {
+	bot.updateTypes = make([]tgapi.UpdateType, 0)
+	bot.updateTypes = append(bot.updateTypes, t...)
+	return bot
+}
+
+// SetPayloadType sets the payload encoding type used for callback data.
+// JSON stores payload as a string: `{"cmd":"command","args":[...]}`.
+// Base64 stores the same JSON encoded as a Base64URL string.
+func (bot *Bot[T]) SetPayloadType(t BotPayloadType) *Bot[T] {
+	bot.payloadType = t
+	return bot
+}
+
+// AddUpdateType adds one or more update types to the list.
+// Does not overwrite existing types.
+func (bot *Bot[T]) AddUpdateType(t ...tgapi.UpdateType) *Bot[T] {
+	bot.updateTypes = append(bot.updateTypes, t...)
+	return bot
+}
+
+// AddPrefixes adds one or more command prefixes (e.g., "/", "!").
+// Must have at least one prefix before Run().
+func (bot *Bot[T]) AddPrefixes(prefixes ...string) *Bot[T] {
+	bot.prefixes = append(bot.prefixes, prefixes...)
+	return bot
+}
+
+// ErrorTemplate sets the format string for error messages sent to users.
+// Use "%s" to insert the error message.
+// Example: "❌ Error: %s" → "❌ Error: Command not found".
+func (bot *Bot[T]) ErrorTemplate(s string) *Bot[T] {
+	bot.errorTemplate = s
+	return bot
+}
+
+// Debug enables or disables debug logging.
+func (bot *Bot[T]) Debug(debug bool) *Bot[T] {
+	bot.debug = debug
+	return bot
+}
+
+// AddPlugins registers one or more plugins.
+// Plugins are executed in registration order unless filtered by middleware.
+func (bot *Bot[T]) AddPlugins(plugin ...*Plugin[T]) *Bot[T] {
+	for _, p := range plugin {
+		bot.plugins = append(bot.plugins, *p)
+		bot.logger.Debugln(fmt.Sprintf("plugins with name \"%s\" registered", p.name))
+	}
+	return bot
+}
+
+// AddMiddleware registers one or more middleware handlers.
+//
+// Middleware are executed in order of increasing .order value before plugins.
+// If two middleware have the same order, they are sorted lexicographically by name.
+//
+// Middleware can:
+//   - Modify or reject updates before they reach plugins
+//   - Inject context (e.g., user auth state, rate limit status)
+//   - Log, validate, or transform incoming data
+//
+// Example:
+//
+//	bot.AddMiddleware(&authMiddleware, &rateLimitMiddleware)
+//
+// Panics if any middleware has a nil name.
+func (bot *Bot[T]) AddMiddleware(middleware ...Middleware[T]) *Bot[T] {
+	for _, m := range middleware {
+		if m.name == "" {
+			panic("laniakea: middleware must have a non-empty name")
+		}
+		bot.middlewares = append(bot.middlewares, m)
+		bot.logger.Debugln(fmt.Sprintf("middleware with name \"%s\" registered", m.name))
+	}
+
+	// Stable sort by order (ascending), then by name (lexicographic)
+	sort.Slice(bot.middlewares, func(i, j int) bool {
+		first := bot.middlewares[i]
+		second := bot.middlewares[j]
+		if first.order != second.order {
+			return first.order < second.order
+		}
+		return first.name < second.name
+	})
+
+	return bot
+}
+
+// AddRunner registers a background runner to execute concurrently with the bot.
+//
+// Runners are goroutines that run independently of update processing.
+// Common use cases:
+//   - Periodic cleanup (e.g., expiring drafts, clearing temp files)
+//   - Metrics collection or health checks
+//   - Scheduled tasks (e.g., daily announcements)
+//
+// Runners are started immediately after Bot.Run() is called.
+//
+// Example:
+//
+//	bot.AddRunner(&cleanupRunner)
+//
+// Panics if runner has a nil name.
+func (bot *Bot[T]) AddRunner(runner Runner[T]) *Bot[T] {
+	if runner.name == "" {
+		panic("laniakea: runner must have a non-empty name")
+	}
+	bot.runners = append(bot.runners, runner)
+	bot.logger.Debugln(fmt.Sprintf("runner with name \"%s\" registered", runner.name))
+	return bot
+}
+
+// AddL10n sets the localization (i18n) provider for the bot.
+//
+// The L10n instance must be pre-populated with translations.
+// Translations are accessed via Bot.L10n(lang, key).
+//
+// Example:
+//
+//	l10n := l10n.New()
+//	l10n.Add("en", "hello", "Hello!")
+//	l10n.Add("es", "hello", "¡Hola!")
+//	bot.AddL10n(l10n)
+//
+// Replaces any previously set L10n instance.
+func (bot *Bot[T]) AddL10n(l *L10n) *Bot[T] {
+	if l == nil {
+		bot.logger.Warn("AddL10n called with nil L10n; localization will be disabled")
+		return bot
+	}
+	bot.l10n = l
+	return bot
+}
+
+// AddDatabaseLoggerWriter adds a database logger writer to all loggers.
+//
+// The writer will receive logs from:
+//   - Main bot logger
+//   - Request logger (if enabled)
+//   - API and Uploader loggers
+//
+// Example:
+//
+//	bot.AddDatabaseLoggerWriter(func(db *MyDB) slog.LoggerWriter {
+//	    return db.QueryLogger()
+//	})
+func (bot *Bot[T]) AddDatabaseLoggerWriter(writer DbLogger[T]) *Bot[T] {
+	w := writer(bot.dbContext)
+	bot.logger.AddWriter(w)
+	if bot.RequestLogger != nil {
+		bot.RequestLogger.AddWriter(w)
+	}
+	for _, l := range bot.extraLoggers {
+		l.AddWriter(w)
+	}
+	return bot
+}
+
+// RunWithContext starts the bot with a given context for graceful shutdown.
+//
+// This is the main entry point for bot execution. It:
+//   - Validates required configuration (prefixes, plugins)
+//   - Starts all registered runners as background goroutines
+//   - Begins polling for updates via Telegram's GetUpdates API
+//   - Processes updates concurrently using a worker pool with size configurable via BotOpts.MaxWorkers
+//
+// The context controls graceful shutdown. When canceled, the bot:
+//   - Stops polling for new updates
+//   - Finishes processing currently queued updates
+//   - Closes all resources (API, uploader, loggers)
+//
+// Example:
+//
+//	ctx, cancel := context.WithCancel(context.Background())
+//	go bot.RunWithContext(ctx)
+//	// ... later ...
+//	cancel() // triggers graceful shutdown
+func (bot *Bot[T]) RunWithContext(ctx context.Context) {
+	defer func() {
+		if err := bot.Close(); err != nil {
+			bot.logger.Errorln(err)
+		}
+	}()
+
+	if len(bot.prefixes) == 0 {
+		bot.logger.Fatalln("no prefixes defined")
+		return
+	}
+
+	if len(bot.plugins) == 0 {
+		bot.logger.Fatalln("no plugins defined")
+		return
+	}
+
+	bot.ExecRunners(ctx)
+
+	bot.logger.Infoln("Bot running. Press CTRL+C to exit.")
+
+	// Start update polling in a goroutine
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				bot.logger.Errorln(fmt.Sprintf("panic in update polling: %v", r))
+			}
+			close(bot.updateQueue)
+		}()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+				updates, err := bot.Updates()
+				if err != nil {
+					bot.logger.Errorln("failed to fetch updates:", err)
+					time.Sleep(2 * time.Second) // exponential backoff
+					continue
+				}
+
+				for _, u := range updates {
+					u := u // copy loop variable to avoid race condition
+					select {
+					case bot.updateQueue <- &u:
+					case <-ctx.Done():
+						return
+					}
+				}
+			}
+		}
+	}()
+
+	// Start worker pool for concurrent update handling
+	pool := pond.NewPool(bot.maxWorkers)
+	for update := range bot.updateQueue {
+		u := update // capture loop variable
+		pool.Submit(func() {
+			bot.handle(u)
+		})
+	}
+	pool.Stop() // Wait for all tasks to complete and stop the pool
+	bot.runnerOnceWG.Wait()
+	bot.runnerBgWG.Wait()
+}
+
+// Run starts the bot using a background context.
+//
+// Equivalent to RunWithContext(context.Background()).
+// Use this for simple bots where graceful shutdown is not required.
+//
+// For production use, prefer RunWithContext to handle SIGINT/SIGTERM gracefully.
+func (bot *Bot[T]) Run() {
+	bot.RunWithContext(context.Background())
+}

bot_opts.go

@@ -0,0 +1,246 @@
+package laniakea
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+)
+
+// BotOpts holds configuration options for initializing a Bot.
+//
+// Values are loaded from environment variables via LoadOptsFromEnv().
+// Use NewOpts() to create a zero-value struct and set fields manually.
+type BotOpts struct {
+	// Token is the Telegram bot token (required).
+	Token string
+
+	// UpdateTypes is a list of update types to listen for.
+	// Example: "["message", "edited_message", "callback_query"]"
+	// Defaults to empty (Telegram will return all types).
+	UpdateTypes []tgapi.UpdateType
+
+	// Debug enables debug-level logging.
+	Debug bool
+
+	// ErrorTemplate is the format string used to wrap error messages sent to users.
+	// Use "%s" to insert the actual error. Example: "❌ Error: %s"
+	ErrorTemplate string
+
+	// Prefixes is a list of command prefixes (e.g., ["/", "!"]).
+	// Defaults to ["/"] if not set via environment.
+	Prefixes []string
+
+	// LoggerBasePath is the directory where log files are written.
+	// Defaults to "./".
+	LoggerBasePath string
+
+	// UseRequestLogger enables detailed logging of all Telegram API requests.
+	UseRequestLogger bool
+
+	// WriteToFile enables writing logs to files (main.log and requests.log).
+	WriteToFile bool
+
+	// UseTestServer uses Telegram's test server (https://api.test.telegram.org).
+	UseTestServer bool
+
+	// APIUrl overrides the default Telegram API endpoint (useful for proxies or self-hosted).
+	APIUrl string
+
+	// RateLimit is the maximum number of API requests per second.
+	// Telegram allows up to 30 req/s for most bots. Defaults to 30.
+	RateLimit int
+
+	// DropRLOverflow drops incoming updates when rate limit is exceeded instead of queuing.
+	// Use this to prioritize responsiveness over reliability.
+	DropRLOverflow bool
+
+	// MaxWorkers is the maximum number of concurrency running update handlers.
+	MaxWorkers int
+}
+
+// LoadOptsFromEnv loads BotOpts from environment variables.
+//
+// Environment variables:
+//   - TG_TOKEN: Bot token (required)
+//   - UPDATE_TYPES: semicolon-separated update types (e.g., "message;callback_query")
+//   - DEBUG: "true" to enable debug logging
+//   - ERROR_TEMPLATE: format string for error messages (e.g., "❌ %s")
+//   - PREFIXES: semicolon-separated prefixes (e.g., "/;!bot")
+//   - LOGGER_BASE_PATH: directory for log files (default: "./")
+//   - USE_REQ_LOG: "true" to enable request logging
+//   - WRITE_TO_FILE: "true" to write logs to files
+//   - USE_TEST_SERVER: "true" to use Telegram test server
+//   - API_URL: custom API endpoint
+//   - RATE_LIMIT: max requests per second (default: 30)
+//   - DROP_RL_OVERFLOW: "true" to drop updates on rate limit overflow
+//
+// Returns a populated BotOpts. If TG_TOKEN is missing, behavior is undefined.
+func LoadOptsFromEnv() *BotOpts {
+	rateLimit := 30
+	if rl := os.Getenv("RATE_LIMIT"); rl != "" {
+		if n, err := strconv.Atoi(rl); err == nil {
+			rateLimit = n
+		}
+	}
+
+	stringUpdateTypes := splitEnvList(os.Getenv("UPDATE_TYPES"))
+	updateTypes := make([]tgapi.UpdateType, 0, len(stringUpdateTypes))
+	for _, updateType := range stringUpdateTypes {
+		updateTypes = append(updateTypes, tgapi.UpdateType(updateType))
+	}
+
+	return &BotOpts{
+		Token:       os.Getenv("TG_TOKEN"),
+		UpdateTypes: updateTypes,
+
+		Debug:         os.Getenv("DEBUG") == "true",
+		ErrorTemplate: os.Getenv("ERROR_TEMPLATE"),
+		Prefixes:      LoadPrefixesFromEnv(),
+
+		LoggerBasePath:   os.Getenv("LOGGER_BASE_PATH"),
+		UseRequestLogger: os.Getenv("USE_REQ_LOG") == "true",
+		WriteToFile:      os.Getenv("WRITE_TO_FILE") == "true",
+
+		UseTestServer: os.Getenv("USE_TEST_SERVER") == "true",
+		APIUrl:        os.Getenv("API_URL"),
+
+		RateLimit:      rateLimit,
+		DropRLOverflow: os.Getenv("DROP_RL_OVERFLOW") == "true",
+	}
+}
+
+// SetToken sets the Telegram bot token (required).
+func (opts *BotOpts) SetToken(token string) *BotOpts {
+	opts.Token = token
+	return opts
+}
+
+// SetUpdateTypes sets the list of update types to listen for.
+// If empty (default), Telegram will return all update types.
+// Example: opts.SetUpdateTypes("message", "callback_query").
+func (opts *BotOpts) SetUpdateTypes(types ...tgapi.UpdateType) *BotOpts {
+	opts.UpdateTypes = types
+	return opts
+}
+
+// SetDebug enables or disables debug-level logging.
+// Default is false.
+func (opts *BotOpts) SetDebug(debug bool) *BotOpts {
+	opts.Debug = debug
+	return opts
+}
+
+// SetErrorTemplate sets the format string for error messages sent to users.
+// Use "%s" to insert the actual error. Example: "❌ Error: %s"
+// If not set, defaults to "%s".
+func (opts *BotOpts) SetErrorTemplate(tpl string) *BotOpts {
+	opts.ErrorTemplate = tpl
+	return opts
+}
+
+// SetPrefixes sets the command prefixes (e.g., "/", "!").
+// If not set via environment, defaults to ["/"].
+func (opts *BotOpts) SetPrefixes(prefixes ...string) *BotOpts {
+	opts.Prefixes = prefixes
+	return opts
+}
+
+// SetLoggerBasePath sets the directory where log files are written.
+// Defaults to "./".
+func (opts *BotOpts) SetLoggerBasePath(path string) *BotOpts {
+	opts.LoggerBasePath = path
+	return opts
+}
+
+// SetUseRequestLogger enables detailed logging of all Telegram API requests.
+// Default is false.
+func (opts *BotOpts) SetUseRequestLogger(use bool) *BotOpts {
+	opts.UseRequestLogger = use
+	return opts
+}
+
+// SetWriteToFile enables writing logs to files (main.log and requests.log).
+// Default is false.
+func (opts *BotOpts) SetWriteToFile(write bool) *BotOpts {
+	opts.WriteToFile = write
+	return opts
+}
+
+// SetUseTestServer enables using Telegram's test server (https://api.telegram.org/bot<token>/test).
+// Default is false.
+func (opts *BotOpts) SetUseTestServer(use bool) *BotOpts {
+	opts.UseTestServer = use
+	return opts
+}
+
+// SetAPIUrl overrides the default Telegram API endpoint (useful for proxies or self-hosted).
+// If not set, defaults to "https://api.telegram.org".
+func (opts *BotOpts) SetAPIUrl(url string) *BotOpts {
+	opts.APIUrl = url
+	return opts
+}
+
+// SetRateLimit sets the maximum number of API requests per second.
+// Telegram allows up to 30 req/s for most bots. Defaults to 30.
+func (opts *BotOpts) SetRateLimit(limit int) *BotOpts {
+	opts.RateLimit = limit
+	return opts
+}
+
+// SetDropRLOverflow drops incoming updates when rate limit is exceeded instead of queuing.
+// Use this to prioritize responsiveness over reliability. Default is false.
+func (opts *BotOpts) SetDropRLOverflow(drop bool) *BotOpts {
+	opts.DropRLOverflow = drop
+	return opts
+}
+
+// SetMaxWorkers sets the maximum number of concurrent update handlers.
+// Must be called before NewBot, as the value is captured during bot creation.
+//
+// The optimal value depends on your bot's workload:
+//   - For I/O-bound handlers (e.g., database queries, external API calls), you may
+//     need more workers, but be mindful of downstream service limits.
+//   - For CPU-bound handlers, keep workers close to the number of CPU cores.
+//
+// Recommended starting points (adjust based on profiling and monitoring):
+//   - Small to medium bots with fast handlers: 16–32
+//   - Medium to large bots with fast handlers: 32–64
+//   - Large bots with heavy I/O: 64–128 (ensure your infrastructure can handle it)
+//
+// The default is 32. Monitor queue length and processing latency to fine-tune.
+func (opts *BotOpts) SetMaxWorkers(workers int) *BotOpts {
+	opts.MaxWorkers = workers
+	return opts
+}
+
+// LoadPrefixesFromEnv returns the PREFIXES environment variable split by semicolon.
+// Defaults to ["/"] if not set.
+func LoadPrefixesFromEnv() []string {
+	prefixesS, exists := os.LookupEnv("PREFIXES")
+	if !exists {
+		return []string{"/"}
+	}
+	prefixes := splitEnvList(prefixesS)
+	if len(prefixes) == 0 {
+		return []string{"/"}
+	}
+	return prefixes
+}
+
+func splitEnvList(value string) []string {
+	if value == "" {
+		return nil
+	}
+	parts := strings.Split(value, ";")
+	out := make([]string, 0, len(parts))
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		out = append(out, part)
+	}
+	return out
+}

bot_opts_test.go

@@ -0,0 +1,47 @@
+package laniakea
+
+import (
+	"reflect"
+	"testing"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+)
+
+func TestLoadOptsFromEnvIgnoresEmptyUpdateTypes(t *testing.T) {
+	t.Setenv("UPDATE_TYPES", "")
+
+	opts := LoadOptsFromEnv()
+	if len(opts.UpdateTypes) != 0 {
+		t.Fatalf("expected no update types, got %v", opts.UpdateTypes)
+	}
+}
+
+func TestLoadOptsFromEnvSplitsAndTrimsUpdateTypes(t *testing.T) {
+	t.Setenv("UPDATE_TYPES", "message; ; callback_query ")
+
+	opts := LoadOptsFromEnv()
+	want := []tgapi.UpdateType{tgapi.UpdateTypeMessage, tgapi.UpdateTypeCallbackQuery}
+	if !reflect.DeepEqual(opts.UpdateTypes, want) {
+		t.Fatalf("unexpected update types: got %v want %v", opts.UpdateTypes, want)
+	}
+}
+
+func TestLoadPrefixesFromEnvDefaultsOnEmptyValue(t *testing.T) {
+	t.Setenv("PREFIXES", "")
+
+	got := LoadPrefixesFromEnv()
+	want := []string{"/"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected prefixes: got %v want %v", got, want)
+	}
+}
+
+func TestLoadPrefixesFromEnvDropsEmptyValues(t *testing.T) {
+	t.Setenv("PREFIXES", "/; ; ! ")
+
+	got := LoadPrefixesFromEnv()
+	want := []string{"/", "!"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected prefixes: got %v want %v", got, want)
+	}
+}

cmd_generator.go

@@ -0,0 +1,169 @@
+package laniakea
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+)
+
+// CmdRegexp matches command names allowed for Telegram command registration.
+var CmdRegexp = regexp.MustCompile("^[a-zA-Z0-9]+$")
+
+// ErrTooManyCommands is returned when the total number of registered commands
+// exceeds Telegram's limit of 100 bot commands per bot.
+//
+// Telegram Bot API enforces this limit strictly. If exceeded, SetMyCommands
+// will fail with a 400 error. This error helps catch the issue early during
+// bot initialization.
+var ErrTooManyCommands = errors.New("too many commands. max 100")
+
+// generateBotCommand builds a BotCommand description with generated usage text.
+func generateBotCommand[T any](cmd *Command[T]) tgapi.BotCommand {
+	desc := ""
+	if len(cmd.description) > 0 {
+		desc = cmd.description
+	}
+
+	var descArgs []string
+	for _, a := range cmd.args {
+		if a.required {
+			descArgs = append(descArgs, fmt.Sprintf("<%s>", a.text))
+		} else {
+			descArgs = append(descArgs, fmt.Sprintf("[%s]", a.text))
+		}
+	}
+
+	usage := fmt.Sprintf("Usage: /%s %s", cmd.command, strings.Join(descArgs, " "))
+	if desc != "" {
+		desc = fmt.Sprintf("%s. %s", desc, usage)
+		return tgapi.BotCommand{Command: cmd.command, Description: desc}
+	}
+	return tgapi.BotCommand{Command: cmd.command, Description: usage}
+}
+
+// checkCmdRegex reports whether cmd matches CmdRegexp.
+func checkCmdRegex(cmd string) bool { return CmdRegexp.MatchString(cmd) }
+
+// gatherCommandsForPlugin collects non-skipped, valid commands from one plugin.
+func gatherCommandsForPlugin[T any](pl Plugin[T]) []tgapi.BotCommand {
+	commands := make([]tgapi.BotCommand, 0)
+	for _, cmd := range pl.commands {
+		if cmd.skipAutoCmd {
+			continue
+		}
+		if !checkCmdRegex(cmd.command) {
+			continue
+		}
+		commands = append(commands, generateBotCommand(cmd))
+	}
+	return commands
+}
+
+// gatherCommands collects all commands from all plugins
+// and converts them into tgapi.BotCommand objects.
+// See gatherCommandsForPlugin.
+func gatherCommands[T any](bot *Bot[T]) []tgapi.BotCommand {
+	commands := make([]tgapi.BotCommand, 0)
+	for _, pl := range bot.plugins {
+		if pl.skipAutoCmd {
+			continue
+		}
+		commands = append(commands, gatherCommandsForPlugin(pl)...)
+		bot.logger.Debugln(fmt.Sprintf("Registered %d commands from plugin %s", len(pl.commands), pl.name))
+	}
+	return commands
+}
+
+// AutoGenerateCommands registers all plugin-defined commands with Telegram's Bot API
+// across three scopes:
+//   - Private chats (users)
+//   - Group chats
+//   - Group administrators
+//
+// It first deletes existing commands to ensure a clean state, then sets the new
+// set of commands for all scopes. This ensures consistency even if commands were
+// previously modified manually via @BotFather.
+//
+// Returns ErrTooManyCommands if the total number of commands exceeds 100.
+// Returns any API error from Telegram (e.g., network issues, invalid scope).
+//
+// Important: This method assumes the bot has been properly initialized and
+// the API client is authenticated and ready.
+//
+// Usage:
+//
+//	err := bot.AutoGenerateCommands()
+//	if err != nil {
+//	    log.Fatal(err)
+//	}
+func (bot *Bot[T]) AutoGenerateCommands() error {
+	commands := gatherCommands(bot)
+	if len(commands) > 100 {
+		return ErrTooManyCommands
+	}
+
+	// Clear existing commands to avoid duplication or stale entries
+	_, err := bot.api.DeleteMyCommands(tgapi.DeleteMyCommandsP{})
+	if err != nil {
+		return fmt.Errorf("failed to delete existing commands: %w", err)
+	}
+
+	// Register commands for each scope
+	scopes := []*tgapi.BotCommandScope{
+		{Type: tgapi.BotCommandScopePrivateType},
+		{Type: tgapi.BotCommandScopeGroupType},
+		{Type: tgapi.BotCommandScopeAllChatAdministratorsType},
+	}
+
+	for _, scope := range scopes {
+		_, err = bot.api.SetMyCommands(tgapi.SetMyCommandsP{
+			Commands: commands,
+			Scope:    scope,
+		})
+		if err != nil {
+			return fmt.Errorf("failed to set commands for scope %q: %w", scope.Type, err)
+		}
+	}
+
+	return nil
+}
+
+// AutoGenerateCommandsForScope registers all plugin-defined commands with Telegram's Bot API
+// for the specified command scope. It first deletes any existing commands in that scope
+// to ensure a clean state, then sets the new set of commands.
+//
+// The scope parameter defines where the commands should be available (e.g., private chats,
+// group chats, chat administrators). See tgapi.BotCommandScope and its predefined types.
+//
+// Returns ErrTooManyCommands if the total number of commands exceeds 100.
+// Returns any API error from Telegram (e.g., network issues, invalid scope).
+//
+// Usage:
+//
+//	privateScope := &tgapi.BotCommandScope{Type: tgapi.BotCommandScopePrivateType}
+//	if err := bot.AutoGenerateCommandsForScope(privateScope); err != nil {
+//	    log.Fatal(err)
+//	}
+func (bot *Bot[T]) AutoGenerateCommandsForScope(scope *tgapi.BotCommandScope) error {
+	commands := gatherCommands(bot)
+	if len(commands) > 100 {
+		return ErrTooManyCommands
+	}
+
+	_, err := bot.api.DeleteMyCommands(tgapi.DeleteMyCommandsP{Scope: scope})
+	if err != nil {
+		return fmt.Errorf("failed to delete existing commands: %w", err)
+	}
+
+	_, err = bot.api.SetMyCommands(tgapi.SetMyCommandsP{
+		Commands: commands,
+		Scope:    scope,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to set commands for scope %q: %w", scope.Type, err)
+	}
+	return nil
+}

cmd_generator_test.go

@@ -0,0 +1,64 @@
+package laniakea
+
+import (
+	"errors"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+	"git.nix13.pw/scuroneko/slog"
+)
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return fn(req)
+}
+
+func TestAutoGenerateCommandsChecksLimitBeforeDelete(t *testing.T) {
+	var calls atomic.Int64
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			calls.Add(1)
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(`{"ok":true,"result":true}`)),
+			}, nil
+		}),
+	}
+	api := tgapi.NewAPI(
+		tgapi.NewAPIOpts("token").
+			SetAPIUrl("https://example.test").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		if err := api.CloseApi(); err != nil {
+			t.Fatalf("CloseApi returned error: %v", err)
+		}
+	}()
+
+	plugin := NewPlugin[NoDB]("overflow")
+	exec := func(ctx *MsgContext, db *NoDB) {}
+	for i := 0; i < 101; i++ {
+		plugin.AddCommand(NewCommand(exec, "cmd"+strconv.Itoa(i)))
+	}
+
+	bot := &Bot[NoDB]{
+		api:     api,
+		logger:  slog.CreateLogger(),
+		plugins: []Plugin[NoDB]{*plugin},
+	}
+
+	err := bot.AutoGenerateCommands()
+	if !errors.Is(err, ErrTooManyCommands) {
+		t.Fatalf("expected ErrTooManyCommands, got %v", err)
+	}
+	if calls.Load() != 0 {
+		t.Fatalf("expected no HTTP calls before limit validation, got %d", calls.Load())
+	}
+}

doc.go

@@ -0,0 +1,55 @@
+/*
+Package laniakea provides a modular, extensible framework for building scalable Telegram bots.
+
+It offers a fluent API for configuration and separates concerns through several core concepts:
+
+  - Bot: The central instance managing API communication, update processing, logging,
+    rate limiting, and dependency injection. Created via NewBot[T].
+
+  - Plugins: Organize commands and payloads into reusable units.
+    A plugin can have multiple commands and shared middlewares.
+
+  - Commands: Named bot commands with descriptions, argument validation, and
+    execution logic. Automatically registrable across different chat scopes.
+
+  - Middleware: Functions that intercept and modify updates before they reach plugins.
+    Useful for authentication, logging, validation, etc. Return false to stop processing.
+
+  - MsgContext: Provides access to the incoming update and convenient methods for
+    responding, editing, deleting, and translating messages. Includes built-in rate limiting
+    and error handling. ⚠️ MarkdownV2 methods require manual escaping via EscapeMarkdownV2().
+
+  - InlineKeyboard: A fluent builder for constructing inline keyboards with styled buttons,
+    icons, URLs, and structured callback data (JSON or Base64).
+
+  - DraftProvider: Manages ephemeral, multi-step message drafts with automatic ID generation
+    (random or linear). Drafts can be built incrementally and flushed atomically.
+
+  - L10n: Simple key-based localization system with fallback language support.
+
+  - Runners: Background goroutines for periodic tasks or one‑off initialization,
+    with configurable timeouts and async execution.
+
+  - RateLimiting & Logging: Built‑in rate limiter (respects Telegram's retry_after)
+    and structured logging (JSON stdout + optional file output) with request‑level tracing.
+
+  - Dependency Injection: Pass any custom database context (e.g., *sql.DB) to all handlers
+    via the type parameter T in Bot[T].
+
+Example usage:
+
+	bot := laniakea.NewBot[mydb.DBContext](laniakea.LoadOptsFromEnv()).
+	    DatabaseContext(&myDB).
+	    AddUpdateType(tgapi.UpdateTypeMessage).
+	    AddPrefixes("/", "!").
+	    AddPlugins(&startPlugin, &helpPlugin).
+	    AddMiddleware(&authMiddleware, &logMiddleware).
+	    AddRunner(&cleanupRunner).
+	    AddL10n(l10n.New())
+
+	bot.Run()
+
+All public methods are safe for concurrent use unless stated otherwise.
+Direct field access is not recommended; use provided accessors (e.g., GetDBContext, SetUpdateOffset).
+*/
+package laniakea

drafts.go

@@ -0,0 +1,263 @@
+package laniakea
+
+import (
+	"errors"
+	"math/rand/v2"
+	"sync"
+	"sync/atomic"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+)
+
+// ErrDraftChatIDZero is returned when a draft is used without setting a chat ID.
+var ErrDraftChatIDZero = errors.New("zero draft chat ID")
+
+// draftIdGenerator defines an interface for generating unique draft IDs.
+type draftIdGenerator interface {
+	// Next returns the next unique draft ID.
+	Next() uint64
+}
+
+// RandomDraftIdGenerator generates draft IDs using cryptographically secure random numbers.
+// Suitable for distributed systems or when ID predictability is undesirable.
+type RandomDraftIdGenerator struct{}
+
+// Next returns a random 64-bit unsigned integer.
+func (g *RandomDraftIdGenerator) Next() uint64 {
+	return rand.Uint64()
+}
+
+// LinearDraftIdGenerator generates draft IDs using a monotonically increasing counter.
+// Useful for debugging, persistence, or when drafts must be ordered.
+type LinearDraftIdGenerator struct {
+	lastId atomic.Uint64
+}
+
+// Next returns the next linear ID, atomically incremented.
+func (g *LinearDraftIdGenerator) Next() uint64 {
+	return g.lastId.Add(1)
+}
+
+// DraftProvider manages a collection of Drafts and provides methods to create and
+// configure them. It holds shared configuration (chat, parse mode, entities) and
+// a draft ID generator.
+//
+// DraftProvider is NOT thread-safe. Concurrent access from multiple goroutines
+// requires external synchronization.
+type DraftProvider struct {
+	mu        sync.RWMutex
+	api       *tgapi.API
+	drafts    map[uint64]*Draft
+	generator draftIdGenerator
+}
+
+// NewRandomDraftProvider creates a new DraftProvider using random draft IDs.
+//
+// The provider will use cryptographically secure random numbers for draft IDs.
+// All drafts created via this provider will have unpredictable, unique IDs.
+func NewRandomDraftProvider(api *tgapi.API) *DraftProvider {
+	return &DraftProvider{
+		api: api, generator: &RandomDraftIdGenerator{},
+		drafts: make(map[uint64]*Draft),
+	}
+}
+
+// NewLinearDraftProvider creates a new DraftProvider using linear (incrementing) draft IDs.
+//
+// startValue is the initial value for the counter. Use 0 for fresh start, or a known
+// value to resume from persisted state.
+//
+// This is useful when you need to store draft IDs externally (e.g., in a database)
+// and want to reconstruct drafts after restart.
+func NewLinearDraftProvider(api *tgapi.API, startValue uint64) *DraftProvider {
+	g := &LinearDraftIdGenerator{}
+	g.lastId.Store(startValue)
+	return &DraftProvider{
+		api:       api,
+		generator: g,
+		drafts:    make(map[uint64]*Draft),
+	}
+}
+
+// GetDraft retrieves a draft by its ID.
+//
+// Returns the draft and true if found, or nil and false if not found.
+func (p *DraftProvider) GetDraft(id uint64) (*Draft, bool) {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+	draft, ok := p.drafts[id]
+	return draft, ok
+}
+
+// FlushAll sends all pending drafts as final messages and clears them.
+//
+// If one or more drafts fail to send, FlushAll still attempts all drafts and
+// returns the first encountered error.
+//
+// After successful flush, each draft is removed from the provider and cleared.
+func (p *DraftProvider) FlushAll() error {
+	p.mu.RLock()
+	drafts := make([]*Draft, 0, len(p.drafts))
+	for _, draft := range p.drafts {
+		drafts = append(drafts, draft)
+	}
+	p.mu.RUnlock()
+
+	var firstErr error
+	for _, draft := range drafts {
+		if err := draft.Flush(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}
+
+// Draft represents a single message draft that can be edited and flushed.
+//
+// Drafts are safe to use from a single goroutine. Multiple goroutines must
+// synchronize access manually.
+//
+// Drafts are automatically removed from the provider's map when Flush() succeeds.
+type Draft struct {
+	api      *tgapi.API
+	provider *DraftProvider
+
+	chatID          int64
+	messageThreadID int
+	parseMode       tgapi.ParseMode
+	entities        []tgapi.MessageEntity
+
+	ID      uint64
+	Message string
+}
+
+// NewDraft creates a new draft with the provided parse mode.
+//
+// The draft inherits the provider's chatID, messageThreadID, and entities.
+// If parseMode is zero, the provider's default parseMode is used.
+//
+// Panics if chatID is zero — call SetChat() on the provider first.
+func (p *DraftProvider) NewDraft(parseMode tgapi.ParseMode) *Draft {
+	id := p.generator.Next()
+	draft := &Draft{
+		api:       p.api,
+		provider:  p,
+		parseMode: parseMode,
+		ID:        id,
+		Message:   "",
+	}
+	p.mu.Lock()
+	p.drafts[id] = draft
+	p.mu.Unlock()
+	return draft
+}
+
+// SetChat overrides the draft's target chat and message thread.
+//
+// This is useful for sending a draft to a different chat than the provider's default.
+func (d *Draft) SetChat(chatID int64, messageThreadID int) *Draft {
+	d.chatID = chatID
+	d.messageThreadID = messageThreadID
+	return d
+}
+
+// SetEntities replaces the draft's message entities.
+//
+// Entities are stored by reference. If you plan to mutate the slice later,
+// pass a copy: `SetEntities(append([]tgapi.MessageEntity{}, myEntities...))`.
+func (d *Draft) SetEntities(entities []tgapi.MessageEntity) *Draft {
+	d.entities = entities
+	return d
+}
+
+// Push appends text to the draft and attempts to update the server-side draft.
+//
+// Returns an error if the Telegram API rejects the update (e.g., due to network issues).
+// The draft's Message field is always updated, even if the API call fails.
+//
+// Use this method to build the message incrementally.
+func (d *Draft) Push(text string) error {
+	return d.push(text)
+}
+
+// GetMessage returns the current content of the draft.
+//
+// Useful for inspection, logging, or validation before flushing.
+func (d *Draft) GetMessage() string {
+	return d.Message
+}
+
+// Clear resets the draft's message content to empty string.
+//
+// Does not affect server-side draft — use Flush() for that.
+func (d *Draft) Clear() {
+	d.Message = ""
+}
+
+// Delete removes the draft from its provider and clears its content.
+//
+// This is an internal method used by Flush(). You may call it manually if you
+// want to cancel a draft without sending it.
+func (d *Draft) Delete() {
+	if d.provider != nil {
+		d.provider.mu.Lock()
+		delete(d.provider.drafts, d.ID)
+		d.provider.mu.Unlock()
+	}
+	d.Clear()
+}
+
+// Flush sends the draft as a final message and clears it locally.
+//
+// If successful:
+//   - The message is sent to Telegram.
+//   - The draft's content is cleared.
+//   - The draft is removed from the provider's map.
+//
+// If an error occurs:
+//   - The message is NOT sent.
+//   - The draft remains in the provider and retains its content.
+//   - You can call Flush() again to retry.
+//
+// If the draft is empty, Flush() returns nil without calling the API.
+func (d *Draft) Flush() error {
+	if d.Message == "" {
+		return nil
+	}
+
+	params := tgapi.SendMessageP{
+		ChatID:    d.chatID,
+		ParseMode: d.parseMode,
+		Entities:  d.entities,
+		Text:      d.Message,
+	}
+	if d.messageThreadID > 0 {
+		params.MessageThreadID = d.messageThreadID
+	}
+
+	_, err := d.api.SendMessage(params)
+	if err == nil {
+		d.Delete()
+	}
+	return err
+}
+
+// push is the internal helper for Push(). It updates the server draft via SendMessageDraft.
+func (d *Draft) push(text string) error {
+	if d.chatID == 0 {
+		return ErrDraftChatIDZero
+	}
+	d.Message += text
+	params := tgapi.SendMessageDraftP{
+		ChatID:    d.chatID,
+		DraftID:   d.ID,
+		Text:      d.Message,
+		ParseMode: d.parseMode,
+		Entities:  d.entities,
+	}
+	if d.messageThreadID > 0 {
+		params.MessageThreadID = d.messageThreadID
+	}
+	_, err := d.api.SendMessageDraft(params)
+	return err
+}

go.mod

@@ -1,28 +1,17 @@
 module git.nix13.pw/scuroneko/laniakea
 
-go 1.25.6
+go 1.26
 
 require (
-	github.com/fatih/color v1.18.0
-	github.com/redis/go-redis/v9 v9.17.3
-	github.com/vinovest/sqlx v1.7.1
-	go.mongodb.org/mongo-driver/v2 v2.4.2
+	git.nix13.pw/scuroneko/extypes v1.2.2
+	git.nix13.pw/scuroneko/slog v1.1.2
+	github.com/alitto/pond/v2 v2.7.0
+	golang.org/x/time v0.15.0
 )
 
 require (
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/golang/snappy v1.0.0 // indirect
-	github.com/klauspost/compress v1.16.7 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/muir/sqltoken v0.1.0 // indirect
-	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
-	github.com/xdg-go/scram v1.1.2 // indirect
-	github.com/xdg-go/stringprep v1.0.4 // indirect
-	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/crypto v0.33.0 // indirect
-	golang.org/x/sync v0.11.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
-	golang.org/x/text v0.22.0 // indirect
+	golang.org/x/sys v0.42.0 // indirect
 )

go.sum

@@ -1,87 +1,17 @@
-filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
-filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
-github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
-github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
-github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
-github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+git.nix13.pw/scuroneko/extypes v1.2.2 h1:N54c1ejrPs1yfIkvYuwqI7B1+8S9mDv2GqQA6sct4dk=
+git.nix13.pw/scuroneko/extypes v1.2.2/go.mod h1:b4XYk1OW1dVSiE2MT/OMuX/K/UItf1swytX6eroVYnk=
+git.nix13.pw/scuroneko/slog v1.1.2 h1:pl7tV5FN25Yso7sLYoOgBXi9+jLo5BDJHWmHlNPjpY0=
+git.nix13.pw/scuroneko/slog v1.1.2/go.mod h1:UcfRIHDqpVQHahBGM93awLDK8//AsAvOqBwwbWqMkjM=
+github.com/alitto/pond/v2 v2.7.0 h1:c76L+yN916m/DRXjGCeUBHHu92uWnh/g1bwVk4zyyXg=
+github.com/alitto/pond/v2 v2.7.0/go.mod h1:xkjYEgQ05RSpWdfSd1nM3OVv7TBhLdy7rMp3+2Nq+yE=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/go-sql-driver/mysql v1.9.0 h1:Y0zIbQXhQKmQgTp44Y1dp3wTXcn804QoTptLZT1vtvo=
-github.com/go-sql-driver/mysql v1.9.0/go.mod h1:pDetrLJeA3oMujJuvXc8RJoasr589B6A9fwzD3QMrqw=
-github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
-github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
-github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
-github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
-github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
-github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
-github.com/muir/sqltoken v0.1.0 h1:edosEGsOClOZNfgGQNQSgxR9O6LiVefm2rDRqp2InuI=
-github.com/muir/sqltoken v0.1.0/go.mod h1:lgOIORnKekMsuc/ZwdPOfwz/PtWLPCke43cEbT3uDuY=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/redis/go-redis/v9 v9.17.3 h1:fN29NdNrE17KttK5Ndf20buqfDZwGNgoUr9qjl1DQx4=
-github.com/redis/go-redis/v9 v9.17.3/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/vinovest/sqlx v1.7.1 h1:kdq4v0N9kRLpytWGSWOw4aulOGdQPmIoMR6Y+cTBxow=
-github.com/vinovest/sqlx v1.7.1/go.mod h1:3fAv74r4iDMv2PpFomADb+vex5ukzfYn4GseC9KngD8=
-github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
-github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
-github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
-github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
-github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
-github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
-github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
-github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-go.mongodb.org/mongo-driver/v2 v2.4.2 h1:HrJ+Auygxceby9MLp3YITobef5a8Bv4HcPFIkml1U7U=
-go.mongodb.org/mongo-driver/v2 v2.4.2/go.mod h1:jHeEDJHJq7tm6ZF45Issun9dbogjfnPySb1vXA7EeAI=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
-golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
+golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=

handler.go

@@ -0,0 +1,204 @@
+package laniakea
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+)
+
+// ErrInvalidPayloadType is returned when callback payload encoding type is unknown.
+var ErrInvalidPayloadType = errors.New("invalid payload type")
+
+func (bot *Bot[T]) handle(u *tgapi.Update) {
+	defer func() {
+		if r := recover(); r != nil {
+			bot.logger.Errorln(fmt.Sprintf("panic in handle: %v", r))
+		}
+	}()
+
+	ctx := &MsgContext{
+		Update: *u, Api: bot.api,
+		botLogger:     bot.logger,
+		errorTemplate: bot.errorTemplate,
+		l10n:          bot.l10n,
+		draftProvider: bot.draftProvider,
+		payloadType:   bot.payloadType,
+	}
+	for _, middleware := range bot.middlewares {
+		if !middleware.Execute(ctx, bot.dbContext) {
+			return
+		}
+	}
+
+	if u.CallbackQuery != nil {
+		bot.handleCallback(u, ctx)
+	} else {
+		bot.handleMessage(u, ctx)
+	}
+}
+
+func (bot *Bot[T]) handleMessage(update *tgapi.Update, ctx *MsgContext) {
+	if update.Message == nil {
+		return
+	}
+	if update.Message.From == nil {
+		return
+	}
+
+	var text string
+	if len(update.Message.Text) > 0 {
+		text = update.Message.Text
+	} else {
+		text = update.Message.Caption
+	}
+
+	text = strings.TrimSpace(text)
+	prefix, hasPrefix := bot.checkPrefixes(text)
+	if !hasPrefix {
+		return
+	}
+	ctx.Prefix = prefix
+	ctx.FromID = update.Message.From.ID
+	ctx.From = update.Message.From
+	ctx.Msg = update.Message
+
+	// Убираем префикс
+	text = strings.TrimSpace(text[len(prefix):])
+
+	// Извлекаем команду как первое слово
+	spaceIndex := strings.Index(text, " ")
+	var cmd string
+	var args string
+
+	if spaceIndex == -1 {
+		cmd = text
+		args = ""
+	} else {
+		cmd = text[:spaceIndex]
+		args = strings.TrimSpace(text[spaceIndex:])
+	}
+
+	if strings.Contains(cmd, "@") {
+		botUsername := bot.username
+		if botUsername != "" && strings.HasSuffix(cmd, "@"+botUsername) {
+			cmd = cmd[:len(cmd)-len("@"+botUsername)] // убираем @botname
+		}
+	}
+
+	// Ищем команду по точному совпадению
+	for _, plugin := range bot.plugins {
+		if _, exists := plugin.commands[cmd]; exists {
+			ctx.Text = args
+			ctx.Args = strings.Fields(args) // Убирает лишние пробелы
+			if !plugin.executeMiddlewares(ctx, bot.dbContext) {
+				return
+			}
+			plugin.executeCmd(cmd, ctx, bot.dbContext)
+			return
+		}
+	}
+}
+
+func (bot *Bot[T]) handleCallback(update *tgapi.Update, ctx *MsgContext) {
+	data, err := bot.decodePayload(update.CallbackQuery.Data)
+	if err != nil {
+		bot.logger.Errorln(err)
+		return
+	}
+
+	ctx.FromID = update.CallbackQuery.From.ID
+	ctx.From = &update.CallbackQuery.From
+	if update.CallbackQuery.Message != nil {
+		ctx.Msg = update.CallbackQuery.Message
+		ctx.CallbackMsgId = update.CallbackQuery.Message.MessageID
+	}
+	if update.CallbackQuery.InlineMessageID != nil {
+		ctx.InlineMsgId = *update.CallbackQuery.InlineMessageID
+	}
+	ctx.CallbackQueryId = update.CallbackQuery.ID
+	ctx.Args = data.Args
+
+	for _, plugin := range bot.plugins {
+		_, ok := plugin.payloads[data.Command]
+		if !ok {
+			continue
+		}
+
+		if !plugin.executeMiddlewares(ctx, bot.dbContext) {
+			return
+		}
+		plugin.executePayload(data.Command, ctx, bot.dbContext)
+		return
+	}
+}
+
+func (bot *Bot[T]) checkPrefixes(text string) (string, bool) {
+	for _, prefix := range bot.prefixes {
+		if prefix == "" {
+			continue
+		}
+		if strings.HasPrefix(text, prefix) {
+			return prefix, true
+		}
+	}
+	return "", false
+}
+
+func encodeJsonPayload(d CallbackData) (string, error) {
+	b, err := json.Marshal(d)
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
+func decodeJsonPayload(s string) (CallbackData, error) {
+	var data CallbackData
+	err := json.Unmarshal([]byte(s), &data)
+	return data, err
+}
+func encodeBase64Payload(d CallbackData) (string, error) {
+	data, err := encodeJsonPayload(d)
+	if err != nil {
+		return "", err
+	}
+	dst := make([]byte, base64.RawURLEncoding.EncodedLen(len([]byte(data))))
+	base64.RawURLEncoding.Encode(dst, []byte(data))
+	return string(dst), nil
+}
+
+//	func encodePayload(payloadType BotPayloadType, d CallbackData) (string, error) {
+//		switch payloadType {
+//		case BotPayloadBase64:
+//			return encodeBase64Payload(d)
+//		case BotPayloadJson:
+//			return encodeJsonPayload(d)
+//		}
+//		return "", ErrInvalidPayloadType
+//	}
+func decodeBase64Payload(s string) (CallbackData, error) {
+	b, err := base64.RawURLEncoding.DecodeString(s)
+	if err != nil {
+		return CallbackData{}, err
+	}
+	return decodeJsonPayload(string(b))
+}
+func decodePayload(payloadType BotPayloadType, s string) (CallbackData, error) {
+	switch payloadType {
+	case BotPayloadBase64:
+		return decodeBase64Payload(s)
+	case BotPayloadJson:
+		return decodeJsonPayload(s)
+	}
+	return CallbackData{}, ErrInvalidPayloadType
+}
+
+//	func (bot *Bot[T]) encodePayload(d CallbackData) (string, error) {
+//		return encodePayload(bot.payloadType, d)
+//	}
+func (bot *Bot[T]) decodePayload(s string) (CallbackData, error) {
+	return decodePayload(bot.payloadType, s)
+}

handler_test.go

@@ -0,0 +1,14 @@
+package laniakea
+
+import "testing"
+
+func TestCheckPrefixesSkipsEmptyPrefixes(t *testing.T) {
+	bot := &Bot[NoDB]{prefixes: []string{"", "/"}}
+
+	if prefix, ok := bot.checkPrefixes("hello"); ok {
+		t.Fatalf("unexpected prefix match for plain text: %q", prefix)
+	}
+	if prefix, ok := bot.checkPrefixes("/start"); !ok || prefix != "/" {
+		t.Fatalf("unexpected prefix result: prefix=%q ok=%v", prefix, ok)
+	}
+}

keyboard.go

@@ -0,0 +1,286 @@
+package laniakea
+
+import (
+	"fmt"
+
+	"git.nix13.pw/scuroneko/extypes"
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+)
+
+// ButtonStyleDanger, ButtonStyleSuccess, ButtonStylePrimary are predefined
+// Telegram keyboard button styles for visual feedback.
+//
+// These values map directly to Telegram Bot API's InlineKeyboardButton style field.
+const (
+	ButtonStyleDanger  tgapi.KeyboardButtonStyle = "danger"
+	ButtonStyleSuccess tgapi.KeyboardButtonStyle = "success"
+	ButtonStylePrimary tgapi.KeyboardButtonStyle = "primary"
+)
+
+// InlineKbButtonBuilder is a fluent builder for creating a single inline keyboard button.
+//
+// Use NewInlineKbButton() to start, then chain methods to configure:
+//   - SetIconCustomEmojiId() — adds a custom emoji icon
+//   - SetStyle() — sets visual style (danger/success/primary)
+//   - SetUrl() — makes button open a URL
+//   - SetCallbackDataJson() — attaches structured command + args for bot handling
+//
+// Call build() to produce the final tgapi.InlineKeyboardButton.
+// Builder methods are immutable — each returns a copy.
+type InlineKbButtonBuilder struct {
+	text              string
+	iconCustomEmojiID string
+	style             tgapi.KeyboardButtonStyle
+	url               string
+	callbackData      string
+}
+
+// NewInlineKbButton creates a new button builder with the given display text.
+// The button will have no URL, no style, and no callback data by default.
+func NewInlineKbButton(text string) InlineKbButtonBuilder {
+	return InlineKbButtonBuilder{text: text}
+}
+
+// SetIconCustomEmojiId sets a custom emoji ID to display as the button's icon.
+// This is a Telegram Bot API feature for custom emoji icons.
+func (b InlineKbButtonBuilder) SetIconCustomEmojiId(id string) InlineKbButtonBuilder {
+	b.iconCustomEmojiID = id
+	return b
+}
+
+// SetStyle sets the visual style of the button.
+// Valid values: ButtonStyleDanger, ButtonStyleSuccess, ButtonStylePrimary.
+// If not set, the button uses the default style.
+func (b InlineKbButtonBuilder) SetStyle(style tgapi.KeyboardButtonStyle) InlineKbButtonBuilder {
+	b.style = style
+	return b
+}
+
+// SetUrl sets a URL that will be opened when the button is pressed.
+// If both URL and CallbackData are set, Telegram will prioritize URL.
+func (b InlineKbButtonBuilder) SetUrl(url string) InlineKbButtonBuilder {
+	b.url = url
+	return b
+}
+
+// SetCallbackDataJson sets a structured callback payload that will be sent to the bot
+// when the button is pressed. The command and arguments are serialized as JSON.
+//
+// Args are converted to strings using fmt.Sprint. Non-string types (e.g., int, bool)
+// are safely serialized, but complex structs may not serialize usefully.
+//
+// Example: SetCallbackDataJson("delete_user", 123, "confirm") → {"cmd":"delete_user","args":["123","confirm"]}.
+func (b InlineKbButtonBuilder) SetCallbackDataJson(cmd string, args ...any) InlineKbButtonBuilder {
+	b.callbackData = NewCallbackData(cmd, args...).ToJson()
+	return b
+}
+
+// SetCallbackDataBase64 sets a structured callback payload encoded as Base64.
+// This can be useful when the JSON payload exceeds Telegram's callback data length limit.
+// Args are converted to strings using fmt.Sprint.
+func (b InlineKbButtonBuilder) SetCallbackDataBase64(cmd string, args ...any) InlineKbButtonBuilder {
+	b.callbackData = NewCallbackData(cmd, args...).ToBase64()
+	return b
+}
+
+// build converts the builder state into a tgapi.InlineKeyboardButton.
+// This method is typically called internally by InlineKeyboard.AddButton().
+func (b InlineKbButtonBuilder) build() tgapi.InlineKeyboardButton {
+	return tgapi.InlineKeyboardButton{
+		Text:              b.text,
+		URL:               b.url,
+		Style:             b.style,
+		IconCustomEmojiID: b.iconCustomEmojiID,
+		CallbackData:      b.callbackData,
+	}
+}
+
+// InlineKeyboard is a stateful builder for constructing Telegram inline keyboard layouts.
+//
+// Buttons are added row-by-row. When a row reaches maxRow, it is automatically flushed.
+// Call AddLine() to manually end a row, or Get() to finalize and retrieve the markup.
+//
+// The keyboard is not thread-safe. Build it in a single goroutine.
+type InlineKeyboard struct {
+	CurrentLine extypes.Slice[tgapi.InlineKeyboardButton] // Current row being built
+	Lines       [][]tgapi.InlineKeyboardButton            // Completed rows
+	maxRow      int                                       // Max buttons per row (e.g., 3 or 4)
+
+	payloadType BotPayloadType // Serialization format for callback data (JSON or Base64)
+}
+
+// NewInlineKeyboardJson creates a new keyboard builder with the specified maximum
+// number of buttons per row.
+//
+// Example: NewInlineKeyboardJson(3) creates a keyboard with at most 3 buttons per line.
+func NewInlineKeyboardJson(maxRow int) *InlineKeyboard {
+	return NewInlineKeyboard(BotPayloadJson, maxRow)
+}
+
+// NewInlineKeyboardBase64 creates a new keyboard builder with the specified maximum
+// number of buttons per row, using Base64 encoding for button payloads.
+//
+// Example: NewInlineKeyboardBase64(3) creates a keyboard with at most 3 buttons per line.
+func NewInlineKeyboardBase64(maxRow int) *InlineKeyboard {
+	return NewInlineKeyboard(BotPayloadBase64, maxRow)
+}
+
+// NewInlineKeyboard creates a new keyboard builder with the specified payload encoding
+// type and maximum number of buttons per row.
+//
+// Use NewInlineKeyboardJson or NewInlineKeyboardBase64 for the common cases.
+func NewInlineKeyboard(payloadType BotPayloadType, maxRow int) *InlineKeyboard {
+	return &InlineKeyboard{
+		CurrentLine: make(extypes.Slice[tgapi.InlineKeyboardButton], 0),
+		Lines:       make([][]tgapi.InlineKeyboardButton, 0),
+		maxRow:      maxRow,
+		payloadType: payloadType,
+	}
+}
+
+// SetPayloadType sets the serialization format for callback data added via
+// AddCallbackButton and AddCallbackButtonStyle methods.
+// It should be one of BotPayloadJson or BotPayloadBase64.
+func (in *InlineKeyboard) SetPayloadType(t BotPayloadType) *InlineKeyboard {
+	in.payloadType = t
+	return in
+}
+
+// append adds a button to the current line. If the line is full, it auto-flushes.
+// This is an internal helper used by other builder methods.
+func (in *InlineKeyboard) append(button tgapi.InlineKeyboardButton) *InlineKeyboard {
+	if in.CurrentLine.Len() == in.maxRow {
+		in.AddLine()
+	}
+	in.CurrentLine = in.CurrentLine.Push(button)
+	return in
+}
+
+// AddUrlButton adds a button that opens a URL when pressed.
+// No callback data is attached.
+func (in *InlineKeyboard) AddUrlButton(text, url string) *InlineKeyboard {
+	return in.append(tgapi.InlineKeyboardButton{Text: text, URL: url})
+}
+
+// AddUrlButtonStyle adds a button with a visual style that opens a URL.
+// Style must be one of: ButtonStyleDanger, ButtonStyleSuccess, ButtonStylePrimary.
+func (in *InlineKeyboard) AddUrlButtonStyle(text string, style tgapi.KeyboardButtonStyle, url string) *InlineKeyboard {
+	return in.append(tgapi.InlineKeyboardButton{Text: text, Style: style, URL: url})
+}
+
+// AddCallbackButton adds a button that sends a structured callback payload to the bot.
+// The command and args are serialized according to the current payloadType.
+func (in *InlineKeyboard) AddCallbackButton(text string, cmd string, args ...any) *InlineKeyboard {
+	return in.append(tgapi.InlineKeyboardButton{
+		Text:         text,
+		CallbackData: NewCallbackData(cmd, args...).Encode(in.payloadType),
+	})
+}
+
+// AddCallbackButtonStyle adds a styled callback button.
+// Style affects visual appearance; callback data is sent to bot on press.
+func (in *InlineKeyboard) AddCallbackButtonStyle(text string, style tgapi.KeyboardButtonStyle, cmd string, args ...any) *InlineKeyboard {
+	return in.append(tgapi.InlineKeyboardButton{
+		Text:         text,
+		Style:        style,
+		CallbackData: NewCallbackData(cmd, args...).Encode(in.payloadType),
+	})
+}
+
+// AddButton adds a button pre-configured via InlineKbButtonBuilder.
+// This is the most flexible way to create buttons with custom emoji, style, URL, and callback.
+func (in *InlineKeyboard) AddButton(b InlineKbButtonBuilder) *InlineKeyboard {
+	return in.append(b.build())
+}
+
+// AddLine manually ends the current row and starts a new one.
+// If the current row is empty, nothing happens.
+func (in *InlineKeyboard) AddLine() *InlineKeyboard {
+	if in.CurrentLine.Len() == 0 {
+		return in
+	}
+	in.Lines = append(in.Lines, in.CurrentLine)
+	in.CurrentLine = make(extypes.Slice[tgapi.InlineKeyboardButton], 0)
+	return in
+}
+
+// Get finalizes the keyboard and returns a tgapi.ReplyMarkup.
+// Automatically flushes the current line if not empty.
+//
+// Returns a pointer to a ReplyMarkup suitable for use with tgapi.SendMessage.
+func (in *InlineKeyboard) Get() *tgapi.ReplyMarkup {
+	if in.CurrentLine.Len() > 0 {
+		in.AddLine()
+	}
+	return &tgapi.ReplyMarkup{InlineKeyboard: in.Lines}
+}
+
+// CallbackData represents the structured payload sent when an inline button
+// with callback data is pressed.
+//
+// This structure is serialized to JSON and sent to the bot as a string.
+// The bot should parse this back to determine the command and arguments.
+//
+// Example:
+//
+//	{"cmd":"delete_user","args":["123","confirm"]}
+type CallbackData struct {
+	Command string   `json:"cmd"`  // The command name to route to
+	Args    []string `json:"args"` // Arguments passed as strings
+}
+
+// NewCallbackData creates a new CallbackData instance with the given command and args.
+//
+// All args are converted to strings using fmt.Sprint. This is safe for primitives
+// (int, string, bool, float64) but may not serialize complex structs meaningfully.
+//
+// Use this to build callback payloads for bot command routing.
+func NewCallbackData(command string, args ...any) *CallbackData {
+	stringArgs := make([]string, len(args))
+	for i, arg := range args {
+		stringArgs[i] = fmt.Sprint(arg)
+	}
+	return &CallbackData{
+		Command: command,
+		Args:    stringArgs,
+	}
+}
+
+// ToJson serializes the CallbackData to a JSON string.
+//
+// If serialization fails (e.g., due to unmarshalable fields), returns a fallback
+// JSON object: {"cmd":""} to prevent breaking Telegram's API.
+//
+// This fallback ensures the bot receives a valid JSON payload even if internal
+// errors occur — avoiding "invalid callback_data" errors from Telegram.
+func (d *CallbackData) ToJson() string {
+	data, err := encodeJsonPayload(*d)
+	if err != nil {
+		// Fallback: return minimal valid JSON to avoid Telegram API rejection
+		return `{"cmd":""}`
+	}
+	return data
+}
+
+// ToBase64 serializes the CallbackData to a JSON string and then encodes it as Base64.
+// Returns an empty string if serialization or encoding fails.
+func (d *CallbackData) ToBase64() string {
+	s, err := encodeBase64Payload(*d)
+	if err != nil {
+		return ``
+	}
+	return s
+}
+
+// Encode serializes the CallbackData according to the specified payload type.
+// Supported types: BotPayloadJson and BotPayloadBase64.
+// For unknown types, returns an empty string.
+func (d *CallbackData) Encode(t BotPayloadType) string {
+	switch t {
+	case BotPayloadBase64:
+		return d.ToBase64()
+	case BotPayloadJson:
+		return d.ToJson()
+	}
+	return ""
+}

l10n.go

@@ -0,0 +1,76 @@
+package laniakea
+
+// DictEntry represents a single localized entry with language-to-text mappings.
+// Example: {"ru": "Привет", "en": "Hello"}.
+type DictEntry map[string]string
+
+// L10n is a localization manager that maps keys to language-specific strings.
+type L10n struct {
+	entries      map[string]DictEntry // Map of translation keys to language dictionaries
+	fallbackLang string               // Language code to use when requested language is missing
+}
+
+// NewL10n creates a new L10n instance with the specified fallback language.
+// The fallback language is used when a requested language is not available
+// for a given key.
+//
+// Example: NewL10n("en") will return "Hello" for key "greeting" if "ru" is requested
+// but no "ru" entry exists.
+func NewL10n(fallbackLanguage string) *L10n {
+	return &L10n{
+		entries:      make(map[string]DictEntry),
+		fallbackLang: fallbackLanguage,
+	}
+}
+
+// AddDictEntry adds a new translation entry for the given key.
+// The value must be a DictEntry mapping language codes (e.g., "en", "ru") to their translated strings.
+//
+// If a key already exists, it is overwritten.
+//
+// Returns the L10n instance for method chaining.
+func (l *L10n) AddDictEntry(key string, value DictEntry) *L10n {
+	l.entries[key] = value
+	return l
+}
+
+// GetFallbackLanguage returns the currently configured fallback language code.
+func (l *L10n) GetFallbackLanguage() string {
+	return l.fallbackLang
+}
+
+// Translate retrieves the translation for the given key and language.
+//
+// Behavior:
+//   - If the key exists and the language has a translation → returns the translation
+//   - If the key exists but the language is missing → returns the fallback language's value
+//   - If the key does not exist → returns the key string itself (as fallback)
+//
+// Example:
+//
+//	l.AddDictEntry("greeting", DictEntry{"en": "Hello", "ru": "Привет"})
+//	l.Translate("en", "greeting") → "Hello"
+//	l.Translate("es", "greeting") → "Hello" (fallback to "en")
+//	l.Translate("en", "unknown") → "unknown" (key not found)
+//
+// This behavior ensures that missing translations do not break UI or logs —
+// instead, the original key is displayed, making it easy to identify gaps.
+func (l *L10n) Translate(lang, key string) string {
+	entries, exists := l.entries[key]
+	if !exists {
+		return key // Return key as fallback when translation is missing
+	}
+
+	// Try requested language
+	if translation, ok := entries[lang]; ok {
+		return translation
+	}
+
+	// Fall back to configured fallback language
+	if fallback, ok := entries[l.fallbackLang]; ok {
+		return fallback
+	}
+
+	// If fallback language is also missing, return the key
+	return key
+}

laniakea/bot.go

@@ -1,560 +0,0 @@
-package laniakea
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/redis/go-redis/v9"
-	"github.com/vinovest/sqlx"
-	"go.mongodb.org/mongo-driver/v2/mongo"
-)
-
-type ParseMode string
-
-const (
-	ParseMDV2 ParseMode = "MarkdownV2"
-	ParseHTML ParseMode = "HTML"
-	ParseMD   ParseMode = "Markdown"
-)
-
-type Bot struct {
-	token         string
-	debug         bool
-	errorTemplate string
-
-	logger        *Logger
-	requestLogger *Logger
-
-	plugins     []*Plugin
-	middlewares []*Middleware
-	prefixes    []string
-
-	dbContext *DatabaseContext
-
-	updateOffset int
-	updateTypes  []string
-	updateQueue  *Queue[*Update]
-}
-
-type BotSettings struct {
-	Token            string
-	Debug            bool
-	ErrorTemplate    string
-	Prefixes         []string
-	UpdateTypes      []string
-	LoggerBasePath   string
-	UseRequestLogger bool
-	WriteToFile      bool
-}
-
-func LoadSettingsFromEnv() *BotSettings {
-	return &BotSettings{
-		Token:            os.Getenv("TG_TOKEN"),
-		Debug:            os.Getenv("DEBUG") == "true",
-		ErrorTemplate:    os.Getenv("ERROR_TEMPLATE"),
-		Prefixes:         LoadPrefixesFromEnv(),
-		UpdateTypes:      strings.Split(os.Getenv("UPDATE_TYPES"), ";"),
-		UseRequestLogger: os.Getenv("USE_REQ_LOG") == "true",
-		WriteToFile:      os.Getenv("WRITE_TO_FILE") == "true",
-	}
-}
-
-type MsgContext struct {
-	Bot           *Bot
-	Msg           *Message
-	Update        *Update
-	From          *User
-	CallbackMsgId int
-	FromID        int
-	Prefix        string
-	Text          string
-	Args          []string
-}
-
-type DatabaseContext struct {
-	PostgresSQL *sqlx.DB
-	MongoDB     *mongo.Client
-	Redis       *redis.Client
-}
-
-func NewBot(settings *BotSettings) *Bot {
-	updateQueue := CreateQueue[*Update](256)
-	bot := &Bot{
-		updateOffset: 0, plugins: make([]*Plugin, 0), debug: settings.Debug, errorTemplate: "%s",
-		prefixes: settings.Prefixes, updateTypes: make([]string, 0),
-		updateQueue: updateQueue,
-		token:       settings.Token,
-	}
-
-	if len(settings.ErrorTemplate) > 0 {
-		bot.errorTemplate = settings.ErrorTemplate
-	}
-
-	if len(settings.LoggerBasePath) == 0 {
-		settings.LoggerBasePath = "./"
-	}
-	level := FATAL
-	if settings.Debug {
-		level = DEBUG
-	}
-
-	bot.logger = CreateLogger().Level(level).PrintTraceback(true)
-	bot.logger.AddWriter(bot.logger.CreateStdoutWriter())
-	if settings.WriteToFile {
-		path := fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/"))
-		fileWriter, err := bot.logger.CreateFileWriter(path)
-		if err != nil {
-			bot.logger.Fatal(err)
-		}
-		bot.logger.AddWriter(fileWriter)
-	}
-
-	if settings.UseRequestLogger {
-		bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS")
-		bot.requestLogger.AddWriter(bot.requestLogger.CreateStdoutWriter())
-		if settings.WriteToFile {
-			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/"))
-			fileWriter, err := bot.requestLogger.CreateFileWriter(path)
-			if err != nil {
-				bot.logger.Fatal(err)
-			}
-			bot.requestLogger.AddWriter(fileWriter)
-		}
-	}
-
-	return bot
-}
-
-func (b *Bot) Close() {
-	for _, writer := range b.logger.writers {
-		err := writer.Close()
-		if err != nil {
-			log.Println(err)
-		}
-	}
-}
-
-func (b *Bot) InitDatabaseContext(ctx *DatabaseContext) *Bot {
-	b.dbContext = ctx
-	return b
-}
-func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) *LoggerWriter) *Bot {
-	w := writer(b.dbContext)
-	b.logger.AddWriter(w)
-	if b.requestLogger != nil {
-		b.requestLogger.AddWriter(w)
-	}
-	return b
-}
-
-func (b *Bot) UpdateTypes(t ...string) *Bot {
-	b.updateTypes = make([]string, 0)
-	b.updateTypes = append(b.updateTypes, t...)
-	return b
-}
-func (b *Bot) AddUpdateType(t ...string) *Bot {
-	b.updateTypes = append(b.updateTypes, t...)
-	return b
-}
-
-func (b *Bot) AddPrefixes(prefixes ...string) *Bot {
-	b.prefixes = append(b.prefixes, prefixes...)
-	return b
-}
-
-func LoadPrefixesFromEnv() []string {
-	prefixesS, exists := os.LookupEnv("PREFIXES")
-	if !exists {
-		return []string{"!"}
-	}
-	return strings.Split(prefixesS, ";")
-}
-
-func (b *Bot) ErrorTemplate(s string) *Bot {
-	b.errorTemplate = s
-	return b
-}
-
-func (b *Bot) Debug(debug bool) *Bot {
-	b.debug = debug
-	return b
-}
-
-func (b *Bot) AddPlugins(plugin ...*Plugin) *Bot {
-	b.plugins = append(b.plugins, plugin...)
-	for _, p := range plugin {
-		b.logger.Debug(fmt.Sprintf("plugins with name \"%s\" registered", p.Name))
-	}
-	return b
-}
-
-func (b *Bot) AddMiddleware(middleware ...*Middleware) *Bot {
-	sort.Slice(middleware, func(a, b int) bool {
-		first := middleware[a]
-		second := middleware[b]
-		if first.Order == second.Order {
-			return first.Name < second.Name
-		}
-		return middleware[a].Order < middleware[b].Order
-	})
-
-	b.middlewares = append(b.middlewares, middleware...)
-	for _, m := range middleware {
-		b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" registered", m.Name))
-	}
-	return b
-}
-
-func (b *Bot) Run() {
-	if len(b.prefixes) == 0 {
-		b.logger.Fatal("no prefixes defined")
-		return
-	}
-
-	if len(b.plugins) == 0 {
-		b.logger.Fatal("no plugins defined")
-		return
-	}
-
-	b.logger.Info("Bot running. Press CTRL+C to exit.")
-
-	go func() {
-		for {
-			_, err := b.Updates()
-			if err != nil {
-				b.logger.Error(err)
-			}
-			time.Sleep(time.Millisecond * 10)
-		}
-	}()
-
-	for {
-		queue := b.updateQueue
-		if queue.IsEmpty() {
-			time.Sleep(time.Millisecond * 25)
-			continue
-		}
-
-		u := queue.Dequeue()
-		if u == nil {
-			b.logger.Error("update is nil")
-			continue
-		}
-		ctx := &MsgContext{
-			Bot:    b,
-			Update: u,
-		}
-		for _, middleware := range b.middlewares {
-			middleware.Execute(ctx, b.dbContext)
-		}
-
-		for _, plugin := range b.plugins {
-			if plugin.UpdateListener != nil {
-				(*plugin.UpdateListener)(ctx, b.dbContext)
-			}
-		}
-
-		if u.CallbackQuery != nil {
-			b.handleCallback(u, ctx)
-		} else {
-			b.handleMessage(u, ctx)
-		}
-	}
-}
-
-// {"callback_query":{"chat_instance":"6202057960757700762","data":"aboba","from":{"first_name":"scuroneko","id":314834933,"is_bot":false,"language_code":"ru","username":"scuroneko"},"id":"1352205741990111553","message":{"chat":{"first_name":"scuroneko","id":314834933,"type":"private","username":"scuroneko"},"date":1734338107,"from":{"first_name":"Kurumi","id":7718900880,"is_bot":true,"username":"kurumi_game_bot"},"message_id":19,"reply_markup":{"inline_keyboard":[[{"callback_data":"aboba","text":"Test"},{"callback_data":"another","text":"Another"}]]},"text":"Aboba"}},"update_id":350979488}
-
-func (b *Bot) handleMessage(update *Update, ctx *MsgContext) {
-	var text string
-	if update.Message == nil {
-		return
-	}
-	if len(update.Message.Text) > 0 {
-		text = update.Message.Text
-	} else {
-		text = update.Message.Caption
-	}
-
-	ctx.FromID = update.Message.From.ID
-	ctx.From = update.Message.From
-	ctx.Msg = update.Message
-	text = strings.TrimSpace(text)
-	prefix, hasPrefix := b.checkPrefixes(text)
-	if !hasPrefix {
-		return
-	}
-	ctx.Prefix = prefix
-
-	text = strings.TrimSpace(text[len(prefix):])
-
-	for _, plugin := range b.plugins {
-		// Check every command
-		for cmd := range plugin.Commands {
-			if !strings.HasPrefix(text, cmd) {
-				continue
-			}
-
-			ctx.Text = strings.TrimSpace(text[len(cmd):])
-			ctx.Args = strings.Split(ctx.Text, " ")
-
-			go plugin.Execute(cmd, ctx, b.dbContext)
-		}
-	}
-}
-
-func (b *Bot) handleCallback(update *Update, ctx *MsgContext) {
-	data := new(CallbackData)
-	err := json.Unmarshal([]byte(update.CallbackQuery.Data), data)
-	if err != nil {
-		b.logger.Error(err)
-		return
-	}
-
-	ctx.FromID = update.CallbackQuery.From.ID
-	ctx.From = update.CallbackQuery.From
-	ctx.Msg = update.CallbackQuery.Message
-	ctx.CallbackMsgId = update.CallbackQuery.Message.MessageID
-	ctx.Args = data.Args
-
-	for _, plugin := range b.plugins {
-		_, ok := plugin.Payloads[data.Command]
-		if !ok {
-			continue
-		}
-		go plugin.ExecutePayload(data.Command, ctx, b.dbContext)
-		break
-	}
-}
-
-func (b *Bot) checkPrefixes(text string) (string, bool) {
-	for _, prefix := range b.prefixes {
-		if strings.HasPrefix(text, prefix) {
-			return prefix, true
-		}
-	}
-	return "", false
-}
-
-type AnswerMessage struct {
-	MessageID int
-	Text      string
-	IsMedia   bool
-	Keyboard  *InlineKeyboard
-	ctx       *MsgContext
-}
-
-func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard) *AnswerMessage {
-	params := &EditMessageTextP{
-		MessageID: messageId,
-		ChatID:    ctx.Msg.Chat.ID,
-		Text:      text,
-		ParseMode: ParseMD,
-	}
-	if keyboard != nil {
-		params.ReplyMarkup = keyboard.Get()
-	}
-	msg, err := ctx.Bot.EditMessageText(params)
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-		return nil
-	}
-	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: false,
-	}
-}
-func (m *AnswerMessage) Edit(text string) *AnswerMessage {
-	return m.ctx.edit(m.MessageID, text, nil)
-}
-func (ctx *MsgContext) EditCallback(text string, keyboard *InlineKeyboard) *AnswerMessage {
-	if ctx.CallbackMsgId == 0 {
-		ctx.Bot.logger.Error("Can't edit non-callback update message")
-		return nil
-	}
-
-	return ctx.edit(ctx.CallbackMsgId, text, keyboard)
-}
-func (ctx *MsgContext) EditCallbackf(format string, keyboard *InlineKeyboard, args ...any) *AnswerMessage {
-	return ctx.EditCallback(fmt.Sprintf(format, args...), keyboard)
-}
-
-func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeyboard) *AnswerMessage {
-	params := &EditMessageCaptionP{
-		ChatID:    ctx.Msg.Chat.ID,
-		MessageID: messageId,
-		Caption:   text,
-		ParseMode: ParseMD,
-	}
-	if kb != nil {
-		params.ReplyMarkup = kb.Get()
-	}
-	msg, err := ctx.Bot.EditMessageCaption(params)
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-	}
-	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
-	}
-}
-func (m *AnswerMessage) EditCaption(text string) *AnswerMessage {
-	return m.ctx.editPhotoText(m.MessageID, text, nil)
-}
-func (m *AnswerMessage) EditCaptionKeyboard(text string, kb *InlineKeyboard) *AnswerMessage {
-	return m.ctx.editPhotoText(m.MessageID, text, kb)
-}
-
-func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard) *AnswerMessage {
-	params := &SendMessageP{
-		ChatID:    ctx.Msg.Chat.ID,
-		Text:      text,
-		ParseMode: ParseMD,
-	}
-	if keyboard != nil {
-		params.ReplyMarkup = keyboard.Get()
-	}
-
-	msg, err := ctx.Bot.SendMessage(params)
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-		return nil
-	}
-	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, IsMedia: false, Text: text,
-	}
-}
-func (ctx *MsgContext) Answer(text string) *AnswerMessage {
-	return ctx.answer(text, nil)
-}
-func (ctx *MsgContext) Answerf(template string, args ...any) *AnswerMessage {
-	return ctx.answer(fmt.Sprintf(template, args...), nil)
-}
-func (ctx *MsgContext) Keyboard(text string, kb *InlineKeyboard) *AnswerMessage {
-	return ctx.answer(text, kb)
-}
-
-func (ctx *MsgContext) answerPhoto(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
-	params := &SendPhotoP{
-		ChatID:    ctx.Msg.Chat.ID,
-		Caption:   text,
-		Photo:     photoId,
-		ParseMode: ParseMD,
-	}
-	if kb != nil {
-		params.ReplyMarkup = kb.Get()
-	}
-	msg, err := ctx.Bot.SendPhoto(params)
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-	}
-	return &AnswerMessage{
-		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
-	}
-}
-func (ctx *MsgContext) AnswerPhoto(photoId, text string) *AnswerMessage {
-	return ctx.answerPhoto(photoId, text, nil)
-}
-func (ctx *MsgContext) AnswerPhotoKeyboard(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
-	return ctx.answerPhoto(photoId, text, kb)
-}
-
-func (ctx *MsgContext) delete(messageId int) {
-	_, err := ctx.Bot.DeleteMessage(&DeleteMessageP{
-		ChatID:    ctx.Msg.Chat.ID,
-		MessageID: messageId,
-	})
-	if err != nil {
-		ctx.Bot.logger.Error(err)
-	}
-}
-func (m *AnswerMessage) Delete() {
-	m.ctx.delete(m.MessageID)
-}
-func (ctx *MsgContext) CallbackDelete() {
-	ctx.delete(ctx.CallbackMsgId)
-}
-
-func (ctx *MsgContext) Error(err error) {
-	_, sendErr := ctx.Bot.SendMessage(&SendMessageP{
-		ChatID: ctx.Msg.Chat.ID,
-		Text:   fmt.Sprintf(ctx.Bot.errorTemplate, EscapeMarkdown(err.Error())),
-	})
-	ctx.Bot.logger.Error(err)
-
-	if sendErr != nil {
-		ctx.Bot.logger.Error(sendErr)
-	}
-}
-
-func (b *Bot) Logger() *Logger {
-	return b.logger
-}
-
-type ApiResponse struct {
-	Ok          bool           `json:"ok"`
-	Result      map[string]any `json:"result,omitempty"`
-	Description string         `json:"description,omitempty"`
-	ErrorCode   int            `json:"error_code,omitempty"`
-}
-
-type ApiResponseA struct {
-	Ok          bool   `json:"ok"`
-	Result      []any  `json:"result,omitempty"`
-	Description string `json:"description,omitempty"`
-	ErrorCode   int    `json:"error_code,omitempty"`
-}
-
-// request is a low-level call to api.
-func (b *Bot) request(methodName string, params any) (map[string]interface{}, error) {
-	var buf bytes.Buffer
-	err := json.NewEncoder(&buf).Encode(params)
-	if err != nil {
-		return nil, err
-	}
-
-	if b.debug && b.requestLogger != nil {
-		b.requestLogger.Debug(strings.ReplaceAll(fmt.Sprintf(
-			"POST https://api.telegram.org/bot%s/%s %s",
-			"<TOKEN>",
-			methodName,
-			buf.String(),
-		), "\n", ""))
-	}
-	r, err := http.Post(fmt.Sprintf("https://api.telegram.org/bot%s/%s", b.token, methodName), "application/json", &buf)
-	if err != nil {
-		return nil, err
-	}
-	defer r.Body.Close()
-	data, err := io.ReadAll(r.Body)
-	if err != nil {
-		return nil, err
-	}
-	b.requestLogger.Debug(fmt.Sprintf("RES %s %s", methodName, string(data)))
-	response := new(ApiResponse)
-
-	var result map[string]any
-
-	err = json.Unmarshal(data, &response)
-	if err != nil {
-		responseArray := new(ApiResponseA)
-		err = json.Unmarshal(data, responseArray)
-		if err != nil {
-			return nil, err
-		}
-		result = map[string]interface{}{
-			"data": responseArray.Result,
-		}
-	} else {
-		result = response.Result
-	}
-	if !response.Ok {
-		return nil, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description)
-	}
-	return result, err
-}

laniakea/keyboard.go

@@ -1,74 +0,0 @@
-package laniakea
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-type InlineKeyboard struct {
-	CurrentLine []InlineKeyboardButton
-	Lines       [][]InlineKeyboardButton
-	maxRow      int
-}
-
-func NewInlineKeyboard(maxRow int) *InlineKeyboard {
-	return &InlineKeyboard{
-		CurrentLine: make([]InlineKeyboardButton, 0),
-		Lines:       make([][]InlineKeyboardButton, 0),
-		maxRow:      maxRow,
-	}
-}
-
-func (in *InlineKeyboard) append(button InlineKeyboardButton) *InlineKeyboard {
-	if len(in.CurrentLine) == in.maxRow {
-		in.AddLine()
-	}
-	in.CurrentLine = append(in.CurrentLine, button)
-	return in
-}
-func (in *InlineKeyboard) AddUrlButton(text, url string) *InlineKeyboard {
-	return in.append(InlineKeyboardButton{Text: text, URL: url})
-}
-func (in *InlineKeyboard) AddCallbackButton(text string, cmd string, args ...any) *InlineKeyboard {
-	return in.append(InlineKeyboardButton{Text: text, CallbackData: NewCallbackData(cmd, args...).ToJson()})
-}
-
-func (in *InlineKeyboard) AddLine() *InlineKeyboard {
-	if len(in.CurrentLine) == 0 {
-		return in
-	}
-	in.Lines = append(in.Lines, in.CurrentLine)
-	in.CurrentLine = make([]InlineKeyboardButton, 0)
-	return in
-}
-func (in *InlineKeyboard) Get() InlineKeyboardMarkup {
-	if len(in.CurrentLine) > 0 {
-		in.Lines = append(in.Lines, in.CurrentLine)
-	}
-	return InlineKeyboardMarkup{
-		InlineKeyboard: in.Lines,
-	}
-}
-
-type CallbackData struct {
-	Command string   `json:"cmd"`
-	Args    []string `json:"args"`
-}
-
-func NewCallbackData(command string, args ...any) *CallbackData {
-	stringArgs := make([]string, len(args))
-	for i, arg := range args {
-		stringArgs[i] = fmt.Sprint(arg)
-	}
-	return &CallbackData{
-		Command: command,
-		Args:    stringArgs,
-	}
-}
-func (d *CallbackData) ToJson() string {
-	data, err := json.Marshal(d)
-	if err != nil {
-		return `{"cmd":""}`
-	}
-	return string(data)
-}

laniakea/logger.go

@@ -1,259 +0,0 @@
-package laniakea
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/fatih/color"
-)
-
-type LoggerWriter struct {
-	writer  io.Writer
-	writeFn LoggerWriterFn
-	logger  *Logger
-}
-
-func (w *LoggerWriter) SetFn(fn LoggerWriterFn) {
-	w.writeFn = fn
-}
-func (w *LoggerWriter) Write(p []byte) (n int, err error) {
-	return w.writer.Write(p)
-}
-func (w *LoggerWriter) Close() error {
-	return w.writer.(io.Closer).Close()
-}
-
-type LoggerWriterFn func(level LogLevel, prefix, traceback string, message []any) error
-
-type Logger struct {
-	prefix         string
-	level          LogLevel
-	printTraceback bool
-	printTime      bool
-	writers        []*LoggerWriter
-}
-
-type LogLevel struct {
-	n uint8
-	t string
-	c color.Attribute
-}
-
-func (l *LogLevel) GetName() string {
-	return l.t
-}
-
-type MethodTraceback struct {
-	Package   string
-	Method    string
-	fullPath  string
-	signature string
-	filename  string
-	line      int
-}
-
-var (
-	INFO  = LogLevel{n: 0, t: "info", c: color.FgWhite}
-	WARN  = LogLevel{n: 1, t: "warn", c: color.FgHiYellow}
-	ERROR = LogLevel{n: 2, t: "error", c: color.FgHiRed}
-	FATAL = LogLevel{n: 3, t: "fatal", c: color.FgRed}
-	DEBUG = LogLevel{n: 4, t: "debug", c: color.FgGreen}
-)
-
-func CreateLogger() *Logger {
-	return &Logger{
-		prefix:         "LOG",
-		level:          FATAL,
-		printTraceback: false,
-		printTime:      true,
-	}
-}
-
-func (l *Logger) CreateFileWriter(path string) (*LoggerWriter, error) {
-	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
-	if err != nil {
-		return nil, err
-	}
-	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if err != nil {
-		return nil, err
-	}
-
-	writer := &LoggerWriter{
-		writer: file, logger: l,
-	}
-	writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error {
-		_, err = writer.Write([]byte(writer.logger.buildString(level, message) + "\n"))
-		return err
-	}
-	return writer, nil
-}
-func (l *Logger) CreateStdoutWriter() *LoggerWriter {
-	writer := &LoggerWriter{
-		writer: os.Stdout, logger: l,
-	}
-	writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error {
-		_, err := color.New(level.c).Fprint(writer.writer, writer.logger.buildString(level, message))
-		return err
-	}
-	return writer
-}
-
-func (l *Logger) Prefix(prefix string) *Logger {
-	l.prefix = prefix
-	return l
-}
-func (l *Logger) Level(level LogLevel) *Logger {
-	l.level = level
-	return l
-}
-func (l *Logger) PrintTraceback(b bool) *Logger {
-	l.printTraceback = b
-	return l
-}
-func (l *Logger) PrintTime(b bool) *Logger {
-	l.printTime = b
-	return l
-}
-func (l *Logger) AddWriters(writers ...*LoggerWriter) *Logger {
-	l.writers = append(l.writers, writers...)
-	return l
-}
-func (l *Logger) AddWriter(writer *LoggerWriter) *Logger {
-	l.writers = append(l.writers, writer)
-	return l
-}
-
-func (l *Logger) Infof(format string, m ...any) {
-	l.print(INFO, []any{fmt.Sprintf(format, m...)})
-}
-func (l *Logger) Info(m ...any) {
-	l.print(INFO, m)
-}
-
-func (l *Logger) Warn(m ...any) {
-	l.print(WARN, m)
-}
-
-func (l *Logger) Error(m ...any) {
-	l.print(ERROR, m)
-}
-
-func (l *Logger) Fatal(m ...any) {
-	l.print(FATAL, m)
-	os.Exit(1)
-}
-
-func (l *Logger) Debug(m ...any) {
-	l.print(DEBUG, m)
-}
-
-func (l *Logger) formatTime(t time.Time) string {
-	return fmt.Sprintf("%02d.%02d.%02d %02d:%02d:%02d", t.Day(), t.Month(), t.Year(), t.Hour(), t.Minute(), t.Second())
-}
-
-func (l *Logger) getTraceback() *MethodTraceback {
-	caller, _, _, _ := runtime.Caller(4)
-	details := runtime.FuncForPC(caller)
-	signature := details.Name()
-	path, line := details.FileLine(caller)
-	splitPath := strings.Split(path, "/")
-
-	splitSignature := strings.Split(signature, ".")
-	pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
-
-	tb := &MethodTraceback{
-		filename:  splitPath[len(splitPath)-1],
-		fullPath:  path,
-		line:      line,
-		signature: signature,
-		Package:   pkg,
-		Method:    method,
-	}
-
-	return tb
-}
-func (l *Logger) formatTraceback(mt *MethodTraceback) string {
-	return fmt.Sprintf("%s:%s:%d", mt.filename, mt.Method, mt.line)
-}
-
-func (l *Logger) getFullTraceback(skip int) []*MethodTraceback {
-	pc := make([]uintptr, 15)
-	runtime.Callers(skip, pc)
-	list := make([]*MethodTraceback, 0)
-	frames := runtime.CallersFrames(pc)
-	for {
-		frame, more := frames.Next()
-		if !more {
-			break
-		}
-		details := runtime.FuncForPC(frame.PC)
-		signature := details.Name()
-		path, line := details.FileLine(frame.PC)
-		splitPath := strings.Split(path, "/")
-
-		splitSignature := strings.Split(signature, ".")
-		pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1]
-
-		tb := &MethodTraceback{
-			filename:  splitPath[len(splitPath)-1],
-			fullPath:  path,
-			line:      line,
-			signature: signature,
-			Package:   pkg,
-			Method:    method,
-		}
-		list = append(list, tb)
-	}
-	sort.Slice(list, func(i, j int) bool {
-		return j < i
-	})
-	return list
-}
-func (l *Logger) formatFullTraceback(tracebacks []*MethodTraceback) string {
-	formatted := make([]string, 0)
-	for _, tb := range tracebacks {
-		formatted = append(formatted, l.formatTraceback(tb))
-	}
-	return strings.Join(formatted, "->")
-}
-
-func (l *Logger) buildString(level LogLevel, m []any) string {
-	args := []string{
-		fmt.Sprintf("[%s]", l.prefix),
-		fmt.Sprintf("[%s]", strings.ToUpper(level.t)),
-	}
-
-	if l.printTraceback {
-		args = append(args, fmt.Sprintf("[%s]", l.formatTraceback(l.getTraceback())))
-	}
-
-	if l.printTime {
-		args = append(args, fmt.Sprintf("[%s]", l.formatTime(time.Now())))
-	}
-
-	msg := Map(m, func(el any) string {
-		return fmt.Sprintf("%v", el)
-	})
-
-	return fmt.Sprintf("%s %v", strings.Join(args, " "), strings.Join(msg, " "))
-}
-
-func (l *Logger) print(level LogLevel, m []any) {
-	if l.level.n < level.n {
-		return
-	}
-
-	for _, writer := range l.writers {
-		err := writer.writeFn(level, l.prefix, l.formatFullTraceback(l.getFullTraceback(0)), m)
-		if err != nil {
-			l.Error(err)
-		}
-	}
-}

laniakea/methods.go

@@ -1,169 +0,0 @@
-package laniakea
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-var NoParams = make(map[string]any)
-
-func (b *Bot) Updates() ([]*Update, error) {
-	params := make(map[string]any)
-	params["offset"] = b.updateOffset
-	params["timeout"] = 30
-	params["allowed_updates"] = b.updateTypes
-
-	data, err := b.request("getUpdates", params)
-	if err != nil {
-		return nil, err
-	}
-	res := make([]*Update, 0)
-	for _, u := range data["data"].([]any) {
-		updateObj := new(Update)
-		data, err := json.Marshal(u)
-		if err != nil {
-			return res, err
-		}
-		err = json.Unmarshal(data, updateObj)
-		if err != nil {
-			return res, err
-		}
-		//err = MapToStruct(u.(map[string]any), updateObj)
-		//if err != nil {
-		//	return res, err
-		//}
-		b.updateOffset = updateObj.UpdateID + 1
-		err = b.updateQueue.Enqueue(updateObj)
-		if err != nil {
-			return res, err
-		}
-		res = append(res, updateObj)
-
-		if b.debug && b.requestLogger != nil {
-			j, err := MapToJson(u.(map[string]interface{}))
-			if err != nil {
-				b.logger.Error(err)
-			}
-			b.requestLogger.Debug(fmt.Sprintf("UPDATE %s", j))
-		}
-	}
-	return res, err
-}
-
-func (b *Bot) GetMe() (*User, error) {
-	data, err := b.request("getMe", NoParams)
-	if err != nil {
-		return nil, err
-	}
-	user := new(User)
-	err = MapToStruct(data, user)
-	return user, err
-}
-
-type SendMessageP struct {
-	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
-	ChatID               int                  `json:"chat_id"`
-	MessageThreadID      int                  `json:"message_thread_id,omitempty"`
-	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
-	Text                 string               `json:"text"`
-	Entities             []*MessageEntity     `json:"entities,omitempty"`
-	LinkPreviewOptions   *LinkPreviewOptions  `json:"link_preview_options,omitempty"`
-	DisableNotifications bool                 `json:"disable_notifications,omitempty"`
-	ProtectContent       bool                 `json:"protect_content,omitempty"`
-	AllowPaidBroadcast   bool                 `json:"allow_paid_broadcast,omitempty"`
-	MessageEffectID      string               `json:"message_effect_id,omitempty"`
-	ReplyParameters      *ReplyParameters     `json:"reply_parameters,omitempty"`
-	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
-}
-
-func (b *Bot) SendMessage(params *SendMessageP) (*Message, error) {
-	data, err := b.request("sendMessage", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}
-
-type SendPhotoP struct {
-	BusinessConnectionID  string               `json:"business_connection_id,omitempty"`
-	ChatID                int                  `json:"chat_id"`
-	MessageThreadID       int                  `json:"message_thread_id,omitempty"`
-	ParseMode             ParseMode            `json:"parse_mode,omitempty"`
-	Photo                 string               `json:"photo"`
-	Caption               string               `json:"caption,omitempty"`
-	CaptionEntities       []*MessageEntity     `json:"caption_entities,omitempty"`
-	ShowCaptionAboveMedia bool                 `json:"show_caption_above_media"`
-	HasSpoiler            bool                 `json:"has_spoiler"`
-	DisableNotifications  bool                 `json:"disable_notifications,omitempty"`
-	ProtectContent        bool                 `json:"protect_content,omitempty"`
-	AllowPaidBroadcast    bool                 `json:"allow_paid_broadcast,omitempty"`
-	MessageEffectID       string               `json:"message_effect_id,omitempty"`
-	ReplyMarkup           InlineKeyboardMarkup `json:"reply_markup,omitempty"`
-}
-
-func (b *Bot) SendPhoto(params *SendPhotoP) (*Message, error) {
-	data, err := b.request("sendPhoto", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}
-
-type EditMessageTextP struct {
-	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
-	ChatID               int                  `json:"chat_id,omitempty"`
-	MessageID            int                  `json:"message_id,omitempty"`
-	InlineMessageID      string               `json:"inline_message_id,omitempty"`
-	Text                 string               `json:"text"`
-	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
-	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
-}
-
-func (b *Bot) EditMessageText(params *EditMessageTextP) (*Message, error) {
-	data, err := b.request("editMessageText", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}
-
-type EditMessageCaptionP struct {
-	BusinessConnectionID string               `json:"business_connection_id,omitempty"`
-	ChatID               int                  `json:"chat_id,omitempty"`
-	MessageID            int                  `json:"message_id,omitempty"`
-	InlineMessageID      string               `json:"inline_message_id,omitempty"`
-	Caption              string               `json:"caption"`
-	ParseMode            ParseMode            `json:"parse_mode,omitempty"`
-	ReplyMarkup          InlineKeyboardMarkup `json:"reply_markup,omitempty"`
-}
-
-func (b *Bot) EditMessageCaption(params *EditMessageCaptionP) (*Message, error) {
-	data, err := b.request("editMessageCaption", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}
-
-type DeleteMessageP struct {
-	ChatID    int `json:"chat_id"`
-	MessageID int `json:"message_id"`
-}
-
-func (b *Bot) DeleteMessage(params *DeleteMessageP) (*Message, error) {
-	data, err := b.request("deleteMessage", params)
-	if err != nil {
-		return nil, err
-	}
-	message := new(Message)
-	err = MapToStruct(data, message)
-	return message, err
-}

laniakea/plugins.go

@@ -1,116 +0,0 @@
-package laniakea
-
-import "log"
-
-type CommandExecutor func(ctx *MsgContext, dbContext *DatabaseContext)
-
-type PluginBuilder struct {
-	name           string
-	commands       map[string]*CommandExecutor
-	payloads       map[string]*CommandExecutor
-	updateListener *CommandExecutor
-}
-
-type Plugin struct {
-	Name           string
-	Commands       map[string]*CommandExecutor
-	Payloads       map[string]*CommandExecutor
-	UpdateListener *CommandExecutor
-}
-
-func NewPlugin(name string) *PluginBuilder {
-	return &PluginBuilder{
-		name:     name,
-		commands: make(map[string]*CommandExecutor),
-		payloads: make(map[string]*CommandExecutor),
-	}
-}
-
-func (p *PluginBuilder) Command(f CommandExecutor, cmd ...string) *PluginBuilder {
-	for _, c := range cmd {
-		p.commands[c] = &f
-	}
-	return p
-}
-
-func (p *PluginBuilder) Payload(f CommandExecutor, payloads ...string) *PluginBuilder {
-	for _, payload := range payloads {
-		p.payloads[payload] = &f
-	}
-	return p
-}
-
-func (p *PluginBuilder) UpdateListener(listener CommandExecutor) *PluginBuilder {
-	p.updateListener = &listener
-	return p
-}
-
-func (p *PluginBuilder) Build() *Plugin {
-	if len(p.commands) == 0 && len(p.payloads) == 0 {
-		log.Println("no command or payloads")
-	}
-	plugin := &Plugin{
-		Name:           p.name,
-		Commands:       p.commands,
-		Payloads:       p.payloads,
-		UpdateListener: p.updateListener,
-	}
-	return plugin
-}
-
-func (p *Plugin) Execute(cmd string, ctx *MsgContext, dbContext *DatabaseContext) {
-	(*p.Commands[cmd])(ctx, dbContext)
-}
-
-func (p *Plugin) ExecutePayload(payload string, ctx *MsgContext, dbContext *DatabaseContext) {
-	(*p.Payloads[payload])(ctx, dbContext)
-}
-
-type Middleware struct {
-	Name     string
-	Executor *CommandExecutor
-	Order    int
-	Async    bool
-}
-type MiddlewareBuilder struct {
-	name     string
-	executor *CommandExecutor
-	order    int
-	async    bool
-}
-
-func NewMiddleware(name string) *MiddlewareBuilder {
-	return &MiddlewareBuilder{name: name, async: false}
-}
-func (m *MiddlewareBuilder) SetName(name string) *MiddlewareBuilder {
-	m.name = name
-	return m
-}
-func (m *MiddlewareBuilder) SetExecutor(executor CommandExecutor) *MiddlewareBuilder {
-	m.executor = &executor
-	return m
-}
-func (m *MiddlewareBuilder) SetOrder(order int) *MiddlewareBuilder {
-	m.order = order
-	return m
-}
-func (m *MiddlewareBuilder) SetAsync(async bool) *MiddlewareBuilder {
-	m.async = async
-	return m
-}
-func (m *MiddlewareBuilder) Build() *Middleware {
-	return &Middleware{
-		Name:     m.name,
-		Executor: m.executor,
-		Order:    m.order,
-		Async:    m.async,
-	}
-}
-func (m *Middleware) Execute(ctx *MsgContext, db *DatabaseContext) {
-	exec := *m.Executor
-	if m.Async {
-		go exec(ctx, db)
-	} else {
-		exec(ctx, db)
-	}
-}

laniakea/queue.go

@@ -1,69 +0,0 @@
-package laniakea
-
-import (
-	"fmt"
-	"sync"
-)
-
-type Queue[T any] struct {
-	size  uint64
-	mu    sync.RWMutex
-	queue []T
-}
-
-func CreateQueue[T any](size uint64) *Queue[T] {
-	return &Queue[T]{
-		queue: make([]T, 0),
-		size:  size,
-	}
-}
-
-func (q *Queue[T]) Enqueue(el T) error {
-	if q.IsFull() {
-		return fmt.Errorf("queue full")
-	}
-	q.queue = append(q.queue, el)
-	return nil
-}
-
-func (q *Queue[T]) Peak() T {
-	q.mu.RLock()
-	defer q.mu.RUnlock()
-	return q.queue[0]
-}
-
-func (q *Queue[T]) IsEmpty() bool {
-	return q.Length() == 0
-}
-
-func (q *Queue[T]) IsFull() bool {
-	return q.Length() == q.size
-}
-
-func (q *Queue[T]) Length() uint64 {
-	q.mu.RLock()
-	defer q.mu.RUnlock()
-	return uint64(len(q.queue))
-}
-
-func (q *Queue[T]) Dequeue() T {
-	q.mu.RLock()
-	el := q.queue[0]
-	q.mu.RUnlock()
-
-	if q.Length() == 1 {
-		q.mu.Lock()
-		q.queue = make([]T, 0)
-		q.mu.Unlock()
-		return el
-	}
-
-	q.mu.Lock()
-	q.queue = q.queue[1:]
-	q.mu.Unlock()
-	return el
-}
-
-func (q *Queue[T]) Raw() []T {
-	return q.queue
-}

laniakea/types.go

@@ -1,174 +0,0 @@
-package laniakea
-
-type Update struct {
-	UpdateID               int                          `json:"update_id"`
-	Message                *Message                     `json:"message"`
-	EditedMessage          *Message                     `json:"edited_message,omitempty"`
-	ChannelPost            *Message                     `json:"channel_post,omitempty"`
-	EditedChannelPost      *Message                     `json:"edited_channel_post,omitempty"`
-	BusinessConnection     *BusinessConnection          `json:"business_connection,omitempty"`
-	BusinessMessage        *Message                     `json:"business_message,omitempty"`
-	EditedBusinessMessage  *Message                     `json:"edited_business_message,omitempty"`
-	DeletedBusinessMessage *Message                     `json:"deleted_business_messages,omitempty"`
-	MessageReaction        *MessageReactionUpdated      `json:"message_reaction,omitempty"`
-	MessageReactionCount   *MessageReactionCountUpdated `json:"message_reaction_count,omitempty"`
-	CallbackQuery          *CallbackQuery               `json:"callback_query,omitempty"`
-	InlineQuery            int
-	ChosenInlineResult     int
-}
-
-type User struct {
-	ID                      int    `json:"id"`
-	IsBot                   bool   `json:"is_bot"`
-	FirstName               string `json:"first_name"`
-	LastName                string `json:"last_name,omitempty"`
-	Username                string `json:"username,omitempty"`
-	LanguageCode            string `json:"language_code,omitempty"`
-	IsPremium               bool   `json:"is_premium,omitempty"`
-	AddedToAttachmentMenu   bool   `json:"added_to_attachment_menu,omitempty"`
-	CanJoinGroups           bool   `json:"can_join_groups,omitempty"`
-	CanReadAllGroupMessages bool   `json:"can_read_all_group_messages,omitempty"`
-	SupportsInlineQueries   bool   `json:"supports_inline_queries,omitempty"`
-	CanConnectToBusiness    bool   `json:"can_connect_to_business,omitempty"`
-	HasMainWebApp           bool   `json:"has_main_web_app,omitempty"`
-}
-
-type Chat struct {
-	ID        int    `json:"id"`
-	Type      string `json:"type"`
-	Title     string `json:"title,omitempty"`
-	Username  string `json:"username,omitempty"`
-	FirstName string `json:"first_name,omitempty"`
-	LastName  string `json:"last_name,omitempty"`
-	IsForum   bool   `json:"is_forum,omitempty"`
-}
-
-type MessageReplyMarkup struct {
-	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
-}
-
-type Message struct {
-	MessageID       int    `json:"message_id"`
-	MessageThreadID int    `json:"message_thread_id,omitempty"`
-	From            *User  `json:"from,omitempty"`
-	Chat            *Chat  `json:"chat,omitempty"`
-	Text            string `json:"text"`
-
-	Photo          []*PhotoSize `json:"photo,omitempty"`
-	Caption        string       `json:"caption,omitempty"`
-	ReplyToMessage *Message     `json:"reply_to_message"`
-
-	ReplyMarkup *MessageReplyMarkup `json:"reply_markup,omitempty"`
-}
-
-type InaccessableMessage struct {
-	Chat      *Chat `json:"chat"`
-	MessageID int   `json:"message_id"`
-	Date      int   `json:"date"`
-}
-
-type MaybeInaccessibleMessage struct {
-}
-
-type MessageEntity struct {
-	Type          string `json:"type"`
-	Offset        int    `json:"offset"`
-	Length        int    `json:"length"`
-	URL           string `json:"url,omitempty"`
-	User          *User  `json:"user,omitempty"`
-	Language      string `json:"language,omitempty"`
-	CustomEmojiID string `json:"custom_emoji_id,omitempty"`
-}
-
-type ReplyParameters struct {
-	MessageID                int              `json:"message_id"`
-	ChatID                   int              `json:"chat_id,omitempty"`
-	AllowSendingWithoutReply bool             `json:"allow_sending_without_reply,omitempty"`
-	Quote                    string           `json:"quote,omitempty"`
-	QuoteParsingMode         string           `json:"quote_parsing_mode,omitempty"`
-	QuoteEntities            []*MessageEntity `json:"quote_entities,omitempty"`
-	QuotePosition            int              `json:"quote_postigin,omitempty"`
-}
-
-type PhotoSize struct {
-	FileID       string `json:"file_id"`
-	FileUniqueID string `json:"file_unique_id"`
-	Width        int    `json:"width"`
-	Height       int    `json:"height"`
-	FileSize     int    `json:"file_size,omitempty"`
-}
-
-type LinkPreviewOptions struct {
-	IsDisabled       bool   `json:"is_disabled,omitempty"`
-	URL              string `json:"url,omitempty"`
-	PreferSmallMedia bool   `json:"prefer_small_media,omitempty"`
-	PreferLargeMedia bool   `json:"prefer_large_media,omitempty"`
-	ShowAboveText    bool   `json:"show_above_text,omitempty"`
-}
-
-type InlineKeyboardMarkup struct {
-	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard,omitempty"`
-}
-
-type InlineKeyboardButton struct {
-	Text         string `json:"text"`
-	URL          string `json:"url,omitempty"`
-	CallbackData string `json:"callback_data,omitempty"`
-}
-
-type ReplyKeyboardMarkup struct {
-	Keyboard [][]int `json:"keyboard"`
-}
-
-type CallbackQuery struct {
-	ID      string   `json:"id"`
-	From    *User    `json:"from"`
-	Message *Message `json:"message"`
-
-	Data string `json:"data"`
-}
-
-type BusinessConnection struct {
-	ID         string `json:"id"`
-	User       *User  `json:"user"`
-	UserChatID int    `json:"user_chat_id"`
-	Date       int    `json:"date"`
-	CanReply   bool   `json:"can_reply"`
-	IsEnabled  bool   `json:"id_enabled"`
-}
-
-type MessageReactionUpdated struct {
-	Chat        *Chat           `json:"chat"`
-	MessageID   int             `json:"message_id"`
-	User        *User           `json:"user,omitempty"`
-	ActorChat   *Chat           `json:"actor_chat"`
-	Date        int             `json:"date"`
-	OldReaction []*ReactionType `json:"old_reaction"`
-	NewReaction []*ReactionType `json:"new_reaction"`
-}
-
-type MessageReactionCountUpdated struct {
-	Chat      *Chat            `json:"chat"`
-	MessageID int              `json:"message_id"`
-	Date      int              `json:"date"`
-	Reactions []*ReactionCount `json:"reactions"`
-}
-
-type ReactionType struct {
-	Type string `json:"type"`
-}
-type ReactionTypeEmoji struct {
-	ReactionType
-	Emoji string `json:"emoji"`
-}
-type ReactionTypeCustomEmoji struct {
-	ReactionType
-	CustomEmojiID string `json:"custom_emoji_id"`
-}
-type ReactionTypePaid struct {
-	ReactionType
-}
-type ReactionCount struct {
-	Type       *ReactionType `json:"type"`
-	TotalCount int           `json:"total_count"`
-}

laniakea/utils.go

@@ -1,108 +0,0 @@
-package laniakea
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-)
-
-func MapToStruct(m map[string]interface{}, s interface{}) error {
-	data, err := json.Marshal(m)
-	if err != nil {
-		return err
-	}
-	err = json.Unmarshal(data, s)
-	return err
-}
-
-func MapToJson(m map[string]interface{}) (string, error) {
-	data, err := json.Marshal(m)
-	return string(data), err
-}
-
-func StructToMap(s interface{}) (map[string]interface{}, error) {
-	data, err := json.Marshal(s)
-	if err != nil {
-		return nil, err
-	}
-	m := make(map[string]interface{})
-	err = json.Unmarshal(data, &m)
-	return m, err
-}
-
-func Map[T, V any](ts []T, fn func(T) V) []V {
-	result := make([]V, len(ts))
-	for i, t := range ts {
-		result[i] = fn(t)
-	}
-	return result
-}
-
-func EscapeMarkdown(s string) string {
-	s = strings.ReplaceAll(s, "_", `\_`)
-	s = strings.ReplaceAll(s, "*", `\*`)
-	s = strings.ReplaceAll(s, "[", `\[`)
-	return strings.ReplaceAll(s, "`", "\\`")
-}
-
-func EscapeMarkdownV2(s string) string {
-	symbols := []string{"_", "*", "[", "]", "(", ")", "~", "`", ">", "#", "+", "-", "=", "|", "{", "}", ".", "!"}
-	for _, symbol := range symbols {
-		s = strings.ReplaceAll(s, symbol, fmt.Sprintf("\\%s", symbol))
-	}
-	return s
-}
-
-func GetUnclosedTag(markdown string) string {
-	// order is important!
-	var tags = []string{
-		"```",
-		"`",
-		"*",
-		"_",
-	}
-	var currentTag = ""
-
-	markdownRunes := []rune(markdown)
-
-	var i = 0
-outer:
-	for i < len(markdownRunes) {
-		// skip escaped characters (only outside tags)
-		if markdownRunes[i] == '\\' && currentTag == "" {
-			i += 2
-			continue
-		}
-		if currentTag != "" {
-			if strings.HasPrefix(string(markdownRunes[i:]), currentTag) {
-				// turn a tag off
-				i += len(currentTag)
-				currentTag = ""
-				continue
-			}
-		} else {
-			for _, tag := range tags {
-				if strings.HasPrefix(string(markdownRunes[i:]), tag) {
-					// turn a tag on
-					currentTag = tag
-					i += len(currentTag)
-					continue outer
-				}
-			}
-		}
-		i++
-	}
-
-	return currentTag
-}
-func IsValid(markdown string) bool {
-	return GetUnclosedTag(markdown) == ""
-}
-
-func FixMarkdown(markdown string) string {
-	tag := GetUnclosedTag(markdown)
-	if tag == "" {
-		return markdown
-	}
-	return markdown + tag
-}

laniakea/version.go

@@ -1,12 +0,0 @@
-package laniakea
-
-import "os"
-
-const (
-	VersionString = "0.2.0"
-	VersionMajor  = 0
-	VersionMinor  = 2
-	VersionPatch  = 0
-)
-
-var GoVersion = os.Getenv("GoV")

methods.go

@@ -0,0 +1,67 @@
+package laniakea
+
+import (
+	"encoding/json"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+)
+
+// Updates fetches new updates from Telegram API using long polling.
+// It respects the bot's current update offset and automatically advances it
+// after successful retrieval. The method supports selective update types
+// through AllowedUpdates and includes optional request logging.
+//
+// Parameters:
+//   - None (uses bot's internal state for offset and allowed updates)
+//
+// Returns:
+//   - []tgapi.Update: slice of received updates (empty if none available)
+//   - error: any error encountered during the API call
+//
+// Behavior:
+//  1. Uses the bot's current update offset (via GetUpdateOffset)
+//  2. Requests updates with 30-second timeout
+//  3. Filters updates by types specified in bot.GetUpdateTypes()
+//  4. Logs raw update JSON if RequestLogger is configured
+//  5. Automatically updates the offset to the last received update ID + 1
+//  6. Returns all received updates (empty slice if none)
+//
+// Note: This is a blocking call that waits up to 30 seconds for new updates.
+// For non-blocking behavior, consider using webhooks instead.
+//
+// Example:
+//
+//	updates, err := bot.Updates()
+//	if err != nil {
+//	    log.Fatal(err)
+//	}
+//	for _, update := range updates {
+//	    // process update
+//	}
+func (bot *Bot[T]) Updates() ([]tgapi.Update, error) {
+	offset := bot.GetUpdateOffset()
+	params := tgapi.UpdateParams{
+		Offset:         Ptr(offset),
+		Timeout:        Ptr(30),
+		AllowedUpdates: bot.GetUpdateTypes(),
+	}
+
+	updates, err := bot.api.GetUpdates(params)
+	if err != nil {
+		return nil, err
+	}
+
+	if bot.RequestLogger != nil {
+		for _, u := range updates {
+			j, err := json.Marshal(u)
+			if err != nil {
+				bot.GetLogger().Error(err)
+			}
+			bot.RequestLogger.Debugf("UPDATE %s\n", j)
+		}
+	}
+	if len(updates) > 0 {
+		bot.SetUpdateOffset(updates[len(updates)-1].UpdateID + 1)
+	}
+	return updates, err
+}

msg_context.go

@@ -0,0 +1,461 @@
+package laniakea
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+	"git.nix13.pw/scuroneko/slog"
+)
+
+// MsgContext holds the context for handling a Telegram message or callback query.
+// It provides methods to respond, edit, delete, and translate messages, as well as
+// manage inline keyboards and message drafts.
+type MsgContext struct {
+	Api    *tgapi.API
+	Update tgapi.Update
+
+	Msg  *tgapi.Message
+	From *tgapi.User
+
+	InlineMsgId     string
+	CallbackMsgId   int
+	CallbackQueryId string
+	FromID          int64
+	Prefix          string
+	Text            string
+	Args            []string
+
+	errorTemplate string
+	botLogger     *slog.Logger
+	l10n          *L10n
+	draftProvider *DraftProvider
+	payloadType   BotPayloadType
+}
+
+// AnswerMessage represents a message sent or edited via MsgContext.
+// It holds metadata to allow further editing or deletion.
+type AnswerMessage struct {
+	MessageID int
+	Text      string
+	IsMedia   bool
+	ctx       *MsgContext // internal back-reference
+}
+
+// edit is an internal helper to edit a message's text with optional keyboard and parse mode.
+// Used by Edit, EditMarkdown, EditCallback, etc.
+func (ctx *MsgContext) edit(messageId int, text string, keyboard *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
+	params := tgapi.EditMessageTextP{
+		Text:      text,
+		ParseMode: parseMode,
+	}
+	switch {
+	case messageId > 0 && ctx.Msg != nil:
+		params.MessageID = messageId
+		params.ChatID = ctx.Msg.Chat.ID
+	case ctx.InlineMsgId != "":
+		params.InlineMessageID = ctx.InlineMsgId
+	default:
+		ctx.botLogger.Errorln("Can't edit message: no valid message target")
+		return nil
+	}
+	if keyboard != nil {
+		params.ReplyMarkup = keyboard.Get()
+	}
+	msg, _, err := ctx.Api.EditMessageText(params)
+	if err != nil {
+		ctx.botLogger.Errorln(err)
+		return nil
+	}
+	resultMessageID := messageId
+	if msg.MessageID > 0 {
+		resultMessageID = msg.MessageID
+	}
+	return &AnswerMessage{
+		MessageID: resultMessageID, ctx: ctx, Text: text, IsMedia: false,
+	}
+}
+
+// Edit replaces the text of the message without changing the keyboard or parse mode.
+// Uses ParseNone (plain text).
+func (m *AnswerMessage) Edit(text string) *AnswerMessage {
+	return m.ctx.edit(m.MessageID, text, nil, tgapi.ParseNone)
+}
+
+// EditMarkdown replaces the text of the message using MarkdownV2 formatting.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+// Unescaped input may cause Telegram API errors or broken formatting.
+func (m *AnswerMessage) EditMarkdown(text string) *AnswerMessage {
+	return m.ctx.edit(m.MessageID, text, nil, tgapi.ParseMDV2)
+}
+
+// editCallback is an internal helper to edit the message associated with a callback query.
+// Supports both regular callback messages and inline callback messages.
+func (ctx *MsgContext) editCallback(text string, keyboard *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
+	if ctx.CallbackMsgId == 0 && ctx.InlineMsgId == "" {
+		ctx.botLogger.Errorln("Can't edit non-callback update message")
+		return nil
+	}
+	return ctx.edit(ctx.CallbackMsgId, text, keyboard, parseMode)
+}
+
+// EditCallback edits the callback message using plain text (ParseNone).
+func (ctx *MsgContext) EditCallback(text string, keyboard *InlineKeyboard) *AnswerMessage {
+	return ctx.editCallback(text, keyboard, tgapi.ParseNone)
+}
+
+// EditCallbackMarkdown edits the callback message using MarkdownV2.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (ctx *MsgContext) EditCallbackMarkdown(text string, keyboard *InlineKeyboard) *AnswerMessage {
+	return ctx.editCallback(text, keyboard, tgapi.ParseMDV2)
+}
+
+// EditCallbackf formats a string using fmt.Sprintf and edits the callback message with plain text.
+func (ctx *MsgContext) EditCallbackf(format string, keyboard *InlineKeyboard, args ...any) *AnswerMessage {
+	return ctx.editCallback(fmt.Sprintf(format, args...), keyboard, tgapi.ParseNone)
+}
+
+// EditCallbackfMarkdown formats a string using fmt.Sprintf and edits the callback message with MarkdownV2.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (ctx *MsgContext) EditCallbackfMarkdown(format string, keyboard *InlineKeyboard, args ...any) *AnswerMessage {
+	return ctx.editCallback(fmt.Sprintf(format, args...), keyboard, tgapi.ParseMDV2)
+}
+
+// editPhotoText edits the caption of a photo/video message.
+// Returns nil when no valid edit target is available for the current context.
+func (ctx *MsgContext) editPhotoText(messageId int, text string, kb *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
+	params := tgapi.EditMessageCaptionP{
+		Caption:   text,
+		ParseMode: parseMode,
+	}
+	switch {
+	case messageId > 0 && ctx.Msg != nil:
+		params.ChatID = ctx.Msg.Chat.ID
+		params.MessageID = messageId
+	case ctx.InlineMsgId != "":
+		params.InlineMessageID = ctx.InlineMsgId
+	default:
+		ctx.botLogger.Errorln("Can't edit caption: no valid message target")
+		return nil
+	}
+	if kb != nil {
+		params.ReplyMarkup = kb.Get()
+	}
+
+	msg, _, err := ctx.Api.EditMessageCaption(params)
+	if err != nil {
+		ctx.botLogger.Errorln(err)
+		return nil
+	}
+	resultMessageID := messageId
+	if msg.MessageID > 0 {
+		resultMessageID = msg.MessageID
+	}
+	return &AnswerMessage{
+		MessageID: resultMessageID, ctx: ctx, Text: text, IsMedia: true,
+	}
+}
+
+// EditCaption edits the caption of a media message using plain text.
+func (m *AnswerMessage) EditCaption(text string) *AnswerMessage {
+	return m.ctx.editPhotoText(m.MessageID, text, nil, tgapi.ParseNone)
+}
+
+// EditCaptionMarkdown edits the caption of a media message using MarkdownV2.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (m *AnswerMessage) EditCaptionMarkdown(text string) *AnswerMessage {
+	return m.ctx.editPhotoText(m.MessageID, text, nil, tgapi.ParseMDV2)
+}
+
+// EditCaptionKeyboard edits the caption of a media message with a new inline keyboard (plain text).
+func (m *AnswerMessage) EditCaptionKeyboard(text string, kb *InlineKeyboard) *AnswerMessage {
+	return m.ctx.editPhotoText(m.MessageID, text, kb, tgapi.ParseNone)
+}
+
+// EditCaptionKeyboardMarkdown edits the caption of a media message with a new inline keyboard using MarkdownV2.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (m *AnswerMessage) EditCaptionKeyboardMarkdown(text string, kb *InlineKeyboard) *AnswerMessage {
+	return m.ctx.editPhotoText(m.MessageID, text, kb, tgapi.ParseMDV2)
+}
+
+// answer sends a new message with optional keyboard and parse mode.
+// Uses API limiter to respect Telegram rate limits per chat.
+func (ctx *MsgContext) answer(text string, keyboard *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("Can't answer message without a message")
+		return nil
+	}
+	params := tgapi.SendMessageP{
+		ChatID:    ctx.Msg.Chat.ID,
+		Text:      text,
+		ParseMode: parseMode,
+	}
+	if keyboard != nil {
+		params.ReplyMarkup = keyboard.Get()
+	}
+	if ctx.Msg.MessageThreadID > 0 {
+		params.MessageThreadID = ctx.Msg.MessageThreadID
+	}
+	if ctx.Msg.DirectMessageTopic != nil {
+		params.DirectMessagesTopicID = ctx.Msg.DirectMessageTopic.TopicID
+	}
+
+	msg, err := ctx.Api.SendMessage(params)
+	if err != nil {
+		ctx.botLogger.Errorln(err)
+		return nil
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, IsMedia: false, Text: text,
+	}
+}
+
+// Answer sends a plain text message (ParseNone).
+func (ctx *MsgContext) Answer(text string) *AnswerMessage {
+	return ctx.answer(text, nil, tgapi.ParseNone)
+}
+
+// AnswerMarkdown sends a message using MarkdownV2 formatting.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (ctx *MsgContext) AnswerMarkdown(text string) *AnswerMessage {
+	return ctx.answer(text, nil, tgapi.ParseMDV2)
+}
+
+// Answerf formats a string using fmt.Sprintf and sends it as a plain text message.
+func (ctx *MsgContext) Answerf(template string, args ...any) *AnswerMessage {
+	return ctx.answer(fmt.Sprintf(template, args...), nil, tgapi.ParseNone)
+}
+
+// AnswerfMarkdown formats a string using fmt.Sprintf and sends it using MarkdownV2.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (ctx *MsgContext) AnswerfMarkdown(template string, args ...any) *AnswerMessage {
+	return ctx.answer(fmt.Sprintf(template, args...), nil, tgapi.ParseMDV2)
+}
+
+// Keyboard sends a message with an inline keyboard (plain text).
+func (ctx *MsgContext) Keyboard(text string, kb *InlineKeyboard) *AnswerMessage {
+	return ctx.answer(text, kb, tgapi.ParseNone)
+}
+
+// KeyboardMarkdown sends a message with an inline keyboard using MarkdownV2.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (ctx *MsgContext) KeyboardMarkdown(text string, keyboard *InlineKeyboard) *AnswerMessage {
+	return ctx.answer(text, keyboard, tgapi.ParseMDV2)
+}
+
+// answerPhoto sends a photo with optional caption and keyboard.
+func (ctx *MsgContext) answerPhoto(photoId, text string, kb *InlineKeyboard, parseMode tgapi.ParseMode) *AnswerMessage {
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("Can't answer message without a message")
+		return nil
+	}
+	params := tgapi.SendPhotoP{
+		ChatID:    ctx.Msg.Chat.ID,
+		Caption:   text,
+		ParseMode: parseMode,
+		Photo:     photoId,
+	}
+	if kb != nil {
+		params.ReplyMarkup = kb.Get()
+	}
+	if ctx.Msg.MessageThreadID > 0 {
+		params.MessageThreadID = ctx.Msg.MessageThreadID
+	}
+	if ctx.Msg.DirectMessageTopic != nil {
+		params.DirectMessagesTopicID = int(ctx.Msg.DirectMessageTopic.TopicID)
+	}
+
+	msg, err := ctx.Api.SendPhoto(params)
+	if err != nil {
+		ctx.botLogger.Errorln(err)
+		return nil
+	}
+	return &AnswerMessage{
+		MessageID: msg.MessageID, ctx: ctx, Text: text, IsMedia: true,
+	}
+}
+
+// AnswerPhoto sends a photo with plain text caption.
+func (ctx *MsgContext) AnswerPhoto(photoId, text string) *AnswerMessage {
+	return ctx.answerPhoto(photoId, text, nil, tgapi.ParseNone)
+}
+
+// AnswerPhotoMarkdown sends a photo with MarkdownV2 caption.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (ctx *MsgContext) AnswerPhotoMarkdown(photoId, text string) *AnswerMessage {
+	return ctx.answerPhoto(photoId, text, nil, tgapi.ParseMDV2)
+}
+
+// AnswerPhotoKeyboard sends a photo with caption and inline keyboard (plain text).
+func (ctx *MsgContext) AnswerPhotoKeyboard(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
+	return ctx.answerPhoto(photoId, text, kb, tgapi.ParseNone)
+}
+
+// AnswerPhotoKeyboardMarkdown sends a photo with caption and inline keyboard using MarkdownV2.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (ctx *MsgContext) AnswerPhotoKeyboardMarkdown(photoId, text string, kb *InlineKeyboard) *AnswerMessage {
+	return ctx.answerPhoto(photoId, text, kb, tgapi.ParseMDV2)
+}
+
+// AnswerPhotof formats a string and sends it as a photo caption (plain text).
+func (ctx *MsgContext) AnswerPhotof(photoId, template string, args ...any) *AnswerMessage {
+	return ctx.answerPhoto(photoId, fmt.Sprintf(template, args...), nil, tgapi.ParseNone)
+}
+
+// AnswerPhotofMarkdown formats a string and sends it as a photo caption using MarkdownV2.
+//
+// ⚠️ WARNING: User input must be escaped with laniakea.EscapeMarkdownV2() before passing here.
+func (ctx *MsgContext) AnswerPhotofMarkdown(photoId, template string, args ...any) *AnswerMessage {
+	return ctx.answerPhoto(photoId, fmt.Sprintf(template, args...), nil, tgapi.ParseMDV2)
+}
+
+// delete removes a message by ID.
+func (ctx *MsgContext) delete(messageId int) {
+	if messageId == 0 {
+		ctx.botLogger.Errorln("Can't delete message: message ID zero")
+		return
+	}
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("Can't delete message: no chat message context")
+		return
+	}
+	_, err := ctx.Api.DeleteMessage(tgapi.DeleteMessageP{
+		ChatID:    ctx.Msg.Chat.ID,
+		MessageID: messageId,
+	})
+	if err != nil {
+		ctx.botLogger.Errorln(err)
+	}
+}
+
+// Delete removes the message associated with this AnswerMessage.
+func (m *AnswerMessage) Delete() { m.ctx.delete(m.MessageID) }
+
+// CallbackDelete deletes the message that triggered the callback query.
+func (ctx *MsgContext) CallbackDelete() {
+	if ctx.CallbackMsgId == 0 {
+		ctx.botLogger.Errorln("Can't delete callback message: no callback message ID")
+		return
+	}
+	ctx.delete(ctx.CallbackMsgId)
+}
+
+// answerCallbackQuery sends a response to a callback query (optional text/alert/url).
+// Does nothing if CallbackQueryId is empty.
+func (ctx *MsgContext) answerCallbackQuery(url, text string, showAlert bool) {
+	if len(ctx.CallbackQueryId) == 0 {
+		return
+	}
+	_, err := ctx.Api.AnswerCallbackQuery(tgapi.AnswerCallbackQueryP{
+		CallbackQueryID: ctx.CallbackQueryId,
+		Text:            text, ShowAlert: showAlert, URL: url,
+	})
+	if err != nil {
+		ctx.botLogger.Errorln(err)
+	}
+}
+
+// AnswerCbQuery answers the callback query with no text or alert.
+func (ctx *MsgContext) AnswerCbQuery() { ctx.answerCallbackQuery("", "", false) }
+
+// AnswerCbQueryText answers the callback query with a text notification.
+func (ctx *MsgContext) AnswerCbQueryText(text string) { ctx.answerCallbackQuery("", text, false) }
+
+// AnswerCbQueryAlert answers the callback query with a user-visible alert.
+func (ctx *MsgContext) AnswerCbQueryAlert(text string) { ctx.answerCallbackQuery("", text, true) }
+
+// AnswerCbQueryUrl answers the callback query with a URL redirect.
+func (ctx *MsgContext) AnswerCbQueryUrl(u string) { ctx.answerCallbackQuery(u, "", false) }
+
+// SendAction sends a chat action (typing, uploading_photo, etc.) to indicate bot activity.
+func (ctx *MsgContext) SendAction(action tgapi.ChatActionType) {
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("Can't send action without chat message context")
+		return
+	}
+	params := tgapi.SendChatActionP{
+		ChatID: ctx.Msg.Chat.ID, Action: action,
+	}
+	if ctx.Msg.MessageThreadID > 0 {
+		params.MessageThreadID = ctx.Msg.MessageThreadID
+	}
+	_, err := ctx.Api.SendChatAction(params)
+	if err != nil {
+		ctx.botLogger.Errorln(err)
+	}
+}
+
+// error sends an error message to the user and logs it.
+// Uses errorTemplate to format the message.
+// For callbacks: sends as callback answer (no alert).
+// For regular messages: sends as plain text.
+func (ctx *MsgContext) error(err error) {
+	text := fmt.Sprintf(ctx.errorTemplate, err.Error())
+
+	if ctx.CallbackQueryId != "" {
+		ctx.answerCallbackQuery("", text, false)
+	} else {
+		ctx.answer(text, nil, tgapi.ParseNone)
+	}
+	ctx.botLogger.Errorln(err)
+}
+
+// Error is an alias for error().
+func (ctx *MsgContext) Error(err error) { ctx.error(err) }
+
+func (ctx *MsgContext) newDraft(parseMode tgapi.ParseMode) *Draft {
+	if ctx.Msg == nil {
+		ctx.botLogger.Errorln("can't create draft: ctx.Msg is nil")
+		return nil
+	}
+
+	c, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := ctx.Api.Limiter.Wait(c, ctx.Msg.Chat.ID); err != nil {
+		ctx.botLogger.Errorln(err)
+		return nil
+	}
+
+	draft := ctx.draftProvider.NewDraft(parseMode).SetChat(ctx.Msg.Chat.ID, ctx.Msg.MessageThreadID)
+	return draft
+}
+
+// NewDraft creates a new message draft associated with the current chat.
+// Uses the API limiter to avoid rate limiting.
+func (ctx *MsgContext) NewDraft() *Draft {
+	return ctx.newDraft(tgapi.ParseNone)
+}
+
+// NewDraftMarkdown creates a new message draft associated with the current chat,
+// with Markdown V2 parse mode enabled.
+// Uses the API limiter to avoid rate limiting.
+func (ctx *MsgContext) NewDraftMarkdown() *Draft {
+	return ctx.newDraft(tgapi.ParseMDV2)
+}
+
+// Translate looks up a key in the current user's language.
+// Falls back to the bot's default language if user's language is unknown or unsupported.
+func (ctx *MsgContext) Translate(key string) string {
+	if ctx.From == nil {
+		return key
+	}
+	lang := Val(ctx.From.LanguageCode, ctx.l10n.GetFallbackLanguage())
+	return ctx.l10n.Translate(lang, key)
+}
+
+// NewInlineKeyboard creates a new keyboard builder with the context's payload
+// encoding type and the specified maximum number of buttons per row.
+func (ctx *MsgContext) NewInlineKeyboard(maxRow int) *InlineKeyboard {
+	return NewInlineKeyboard(ctx.payloadType, maxRow)
+}

msg_context_test.go

@@ -0,0 +1,64 @@
+package laniakea
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+	"git.nix13.pw/scuroneko/slog"
+)
+
+func TestAnswerPhotoIncludesDirectMessagesTopicID(t *testing.T) {
+	var gotBody map[string]any
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			body, err := io.ReadAll(req.Body)
+			if err != nil {
+				t.Fatalf("failed to read request body: %v", err)
+			}
+			if err := json.Unmarshal(body, &gotBody); err != nil {
+				t.Fatalf("failed to decode request body: %v", err)
+			}
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(`{"ok":true,"result":{"message_id":9,"date":1}}`)),
+			}, nil
+		}),
+	}
+
+	api := tgapi.NewAPI(
+		tgapi.NewAPIOpts("token").
+			SetAPIUrl("https://example.test").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		if err := api.CloseApi(); err != nil {
+			t.Fatalf("CloseApi returned error: %v", err)
+		}
+	}()
+
+	ctx := &MsgContext{
+		Api: api,
+		Msg: &tgapi.Message{
+			Chat:               &tgapi.Chat{ID: 42, Type: string(tgapi.ChatTypePrivate)},
+			DirectMessageTopic: &tgapi.DirectMessageTopic{TopicID: 77},
+		},
+		botLogger: slog.CreateLogger(),
+	}
+
+	answer := ctx.AnswerPhoto("photo-id", "caption")
+	if answer == nil {
+		t.Fatal("expected answer message")
+	}
+	if answer.MessageID != 9 {
+		t.Fatalf("unexpected message id: %d", answer.MessageID)
+	}
+	if got := gotBody["direct_messages_topic_id"]; got != float64(77) {
+		t.Fatalf("unexpected direct_messages_topic_id: %v", got)
+	}
+}

plugins.go

@@ -0,0 +1,320 @@
+package laniakea
+
+import (
+	"errors"
+	"regexp"
+
+	"git.nix13.pw/scuroneko/extypes"
+)
+
+// CommandValueType defines the expected type of a command argument.
+type CommandValueType string
+
+const (
+	// CommandValueStringType expects any non-empty string.
+	CommandValueStringType CommandValueType = "string"
+	// CommandValueIntType expects a decimal integer (digits only).
+	CommandValueIntType CommandValueType = "int"
+	// CommandValueBoolType is reserved for future use (not implemented).
+	CommandValueBoolType CommandValueType = "bool"
+	// CommandValueAnyType accepts any input without validation.
+	CommandValueAnyType CommandValueType = "any"
+)
+
+var (
+	// CommandRegexInt matches one or more digits.
+	CommandRegexInt = regexp.MustCompile(`^\d+$`)
+	// CommandRegexString matches any non-empty string.
+	CommandRegexString = regexp.MustCompile(`^.+$`)
+	// CommandRegexBool matches true or false.
+	CommandRegexBool = regexp.MustCompile(`^(true|false)$`)
+)
+
+// ErrCmdArgCountMismatch is returned when the number of provided arguments
+// is less than the number of required arguments.
+var ErrCmdArgCountMismatch = errors.New("command arg count mismatch")
+
+// ErrCmdArgRegexpMismatch is returned when an argument fails regex validation.
+var ErrCmdArgRegexpMismatch = errors.New("command arg regexp mismatch")
+
+// CommandArg defines a single argument for a command, including type, regex,
+// and whether it is required.
+type CommandArg struct {
+	valueType CommandValueType // Type of expected value
+	text      string           // Human-readable description (not used in validation)
+	regex     *regexp.Regexp   // Regex used to validate input
+	required  bool             // Whether this argument must be provided
+}
+
+// NewCommandArg creates a new CommandArg with the given text and type.
+// Uses a default regex based on the type (string or int).
+// For CommandValueAnyType, no validation is performed.
+func NewCommandArg(text string) *CommandArg {
+	return &CommandArg{CommandValueAnyType, text, CommandRegexString, false}
+}
+
+// SetValueType sets expected value type and switches built-in validation regexp.
+func (c *CommandArg) SetValueType(t CommandValueType) *CommandArg {
+	regex := CommandRegexString
+	switch t {
+	case CommandValueIntType:
+		regex = CommandRegexInt
+	case CommandValueBoolType:
+		regex = CommandRegexBool
+	case CommandValueAnyType:
+		regex = nil // Skip validation
+	}
+	c.valueType = t
+	c.regex = regex
+	return c
+}
+
+// SetRequired marks this argument as required.
+// Returns the receiver for method chaining.
+func (c *CommandArg) SetRequired() *CommandArg {
+	c.required = true
+	return c
+}
+
+// CommandExecutor is the function type that executes a command.
+// It receives the message context and a database context (generic).
+type CommandExecutor[T DbContext] func(ctx *MsgContext, dbContext *T)
+
+// Command represents a bot command with arguments, description, and executor.
+// Can be registered in a Plugin and optionally skipped from auto-generation.
+type Command[T DbContext] struct {
+	command     string                       // The command trigger (e.g., "/start")
+	description string                       // Human-readable description for help
+	exec        CommandExecutor[T]           // Function to execute when command is triggered
+	args        extypes.Slice[CommandArg]    // List of expected arguments
+	middlewares extypes.Slice[Middleware[T]] // Optional middleware chain
+	skipAutoCmd bool                         // If true, this command won't be auto-added to help menus
+}
+
+// NewCommand creates a new Command with the given executor, command string, and arguments.
+// The command string should not include the leading slash (e.g., "start", not "/start").
+func NewCommand[T any](exec CommandExecutor[T], command string, args ...CommandArg) *Command[T] {
+	return &Command[T]{command, "", exec, args, make(extypes.Slice[Middleware[T]], 0), false}
+}
+
+// NewPayload creates a new Command with the given executor, command payload string, and arguments.
+// The command string can contain any symbols, but it is recommended to use only "_", "-", ".", a-z, A-Z, and 0-9.
+func NewPayload[T any](exec CommandExecutor[T], command string, args ...CommandArg) *Command[T] {
+	return &Command[T]{command, "", exec, args, make(extypes.Slice[Middleware[T]], 0), false}
+}
+
+// Use adds a middleware to the command's execution chain.
+// Middlewares are executed in the order they are added.
+func (c *Command[T]) Use(m Middleware[T]) *Command[T] {
+	c.middlewares = c.middlewares.Push(m)
+	return c
+}
+
+// SetDescription sets the human-readable description of the command.
+func (c *Command[T]) SetDescription(desc string) *Command[T] {
+	c.description = desc
+	return c
+}
+
+// SkipCommandAutoGen marks this command to be excluded from auto-generated help menus.
+func (c *Command[T]) SkipCommandAutoGen() *Command[T] {
+	c.skipAutoCmd = true
+	return c
+}
+
+// validateArgs checks if the provided arguments match the command's requirements.
+// Returns ErrCmdArgCountMismatch if too few arguments are provided.
+// Returns ErrCmdArgRegexpMismatch if any argument fails regex validation.
+func (c *Command[T]) validateArgs(args []string) error {
+	// Count required args
+	requiredCount := c.args.Filter(func(a CommandArg) bool { return a.required }).Len()
+	if len(args) < requiredCount {
+		return ErrCmdArgCountMismatch
+	}
+
+	// Validate each argument against its regex
+	for i, arg := range args {
+		if i >= c.args.Len() {
+			// Extra arguments beyond defined args are ignored
+			break
+		}
+		cmdArg := c.args.Get(i)
+		if cmdArg.regex == nil {
+			continue // Skip validation for CommandValueAnyType
+		}
+		if !cmdArg.regex.MatchString(arg) {
+			return ErrCmdArgRegexpMismatch
+		}
+	}
+	return nil
+}
+
+// Plugin represents a collection of commands and payloads (e.g., callback handlers),
+// with shared middleware and configuration.
+type Plugin[T DbContext] struct {
+	name        string                       // Name of the plugin (e.g., "admin", "user")
+	commands    map[string]*Command[T]       // Registered commands (triggered by message)
+	payloads    map[string]*Command[T]       // Registered payloads (triggered by callback data)
+	middlewares extypes.Slice[Middleware[T]] // Shared middlewares for all commands/payloads
+	skipAutoCmd bool                         // If true, all commands in this plugin are excluded from auto-help
+}
+
+// NewPlugin creates a new Plugin with the given name.
+func NewPlugin[T DbContext](name string) *Plugin[T] {
+	return &Plugin[T]{
+		name, make(map[string]*Command[T]),
+		make(map[string]*Command[T]), extypes.Slice[Middleware[T]]{}, false,
+	}
+}
+
+// AddCommand registers a command in the plugin.
+// The command's .command field is used as the key.
+func (p *Plugin[T]) AddCommand(command *Command[T]) *Plugin[T] {
+	p.commands[command.command] = command
+	return p
+}
+
+// NewCommand creates and immediately adds a new command to the plugin.
+// Returns the created command for further configuration.
+func (p *Plugin[T]) NewCommand(exec CommandExecutor[T], command string, args ...CommandArg) *Command[T] {
+	cmd := NewCommand(exec, command, args...)
+	p.AddCommand(cmd)
+	return cmd
+}
+
+// AddPayload registers a payload (e.g., callback query data) in the plugin.
+// Payloads are triggered by inline button callback_data, not by message text.
+func (p *Plugin[T]) AddPayload(command *Command[T]) *Plugin[T] {
+	p.payloads[command.command] = command
+	return p
+}
+
+// NewPayload creates and immediately adds a new payload command to the plugin.
+// Returns the created payload command for further configuration.
+func (p *Plugin[T]) NewPayload(exec CommandExecutor[T], command string, args ...CommandArg) *Command[T] {
+	cmd := NewPayload(exec, command, args...)
+	p.AddPayload(cmd)
+	return cmd
+}
+
+// AddMiddleware adds a middleware to the plugin's global middleware chain.
+// Middlewares are executed before any command or payload.
+func (p *Plugin[T]) AddMiddleware(middleware Middleware[T]) *Plugin[T] {
+	p.middlewares = p.middlewares.Push(middleware)
+	return p
+}
+
+// SkipCommandAutoGen marks the entire plugin to be excluded from auto-generated help menus.
+func (p *Plugin[T]) SkipCommandAutoGen() *Plugin[T] {
+	p.skipAutoCmd = true
+	return p
+}
+
+// executeCmd finds and executes a command by its trigger string.
+// Validates arguments and runs middlewares before executor.
+// On error, sends an error message to the user via ctx.error().
+func (p *Plugin[T]) executeCmd(cmd string, ctx *MsgContext, dbContext *T) {
+	command, exists := p.commands[cmd]
+	if !exists {
+		ctx.error(errors.New("command not found"))
+		return
+	}
+
+	if err := command.validateArgs(ctx.Args); err != nil {
+		ctx.error(err)
+		return
+	}
+
+	// Run command-specific middlewares
+	for _, m := range command.middlewares {
+		if !m.Execute(ctx, dbContext) {
+			return
+		}
+	}
+
+	// Execute command
+	command.exec(ctx, dbContext)
+}
+
+// executePayload finds and executes a payload by its callback_data string.
+// Validates arguments and runs middlewares before executor.
+// On error, sends an error message to the user via ctx.error().
+func (p *Plugin[T]) executePayload(payload string, ctx *MsgContext, dbContext *T) {
+	command, exists := p.payloads[payload]
+	if !exists {
+		ctx.error(errors.New("payload not found"))
+		return
+	}
+
+	if err := command.validateArgs(ctx.Args); err != nil {
+		ctx.error(err)
+		return
+	}
+
+	// Run command-specific middlewares
+	for _, m := range command.middlewares {
+		if !m.Execute(ctx, dbContext) {
+			return
+		}
+	}
+
+	// Execute payload
+	command.exec(ctx, dbContext)
+}
+
+// executeMiddlewares runs all plugin middlewares in order.
+// Returns false if any middleware returns false (blocks execution).
+func (p *Plugin[T]) executeMiddlewares(ctx *MsgContext, db *T) bool {
+	for _, m := range p.middlewares {
+		if !m.Execute(ctx, db) {
+			return false
+		}
+	}
+	return true
+}
+
+// MiddlewareExecutor is the function type for middleware logic.
+// Returns true to continue execution, false to block it.
+// If async, return value is ignored.
+type MiddlewareExecutor[T DbContext] func(ctx *MsgContext, db *T) bool
+
+// Middleware represents a reusable execution interceptor.
+// Can be synchronous (blocking) or asynchronous (non-blocking).
+type Middleware[T DbContext] struct {
+	name     string                // Human-readable name for logging/debugging
+	executor MiddlewareExecutor[T] // Function to execute
+	order    int                   // Optional sort order (not used yet)
+	async    bool                  // If true, runs in goroutine and doesn't block
+}
+
+// NewMiddleware creates a new synchronous middleware.
+func NewMiddleware[T DbContext](name string, executor MiddlewareExecutor[T]) *Middleware[T] {
+	return &Middleware[T]{name, executor, 0, false}
+}
+
+// SetOrder sets the execution order (currently ignored).
+func (m *Middleware[T]) SetOrder(order int) *Middleware[T] {
+	m.order = order
+	return m
+}
+
+// SetAsync marks the middleware to run asynchronously.
+// Execution continues regardless of its return value.
+func (m *Middleware[T]) SetAsync(async bool) *Middleware[T] {
+	m.async = async
+	return m
+}
+
+// Execute runs the middleware.
+// If async, runs in a goroutine and returns true immediately.
+// Otherwise, returns the result of the executor.
+func (m *Middleware[T]) Execute(ctx *MsgContext, db *T) bool {
+	if m.async {
+		ctx := *ctx // copy context to avoid race condition
+		go func(ctx MsgContext) {
+			m.executor(&ctx, db)
+		}(ctx)
+		return true
+	}
+	return m.executor(ctx, db)
+}

plugins_test.go

@@ -0,0 +1,24 @@
+package laniakea
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestValidateArgsRequiresFullMatch(t *testing.T) {
+	intCmd := NewCommand[NoDB](func(ctx *MsgContext, db *NoDB) {}, "int", *NewCommandArg("n").SetValueType(CommandValueIntType).SetRequired())
+	if err := intCmd.validateArgs([]string{"123"}); err != nil {
+		t.Fatalf("expected valid integer argument, got %v", err)
+	}
+	if err := intCmd.validateArgs([]string{"123abc"}); !errors.Is(err, ErrCmdArgRegexpMismatch) {
+		t.Fatalf("expected ErrCmdArgRegexpMismatch for partial int match, got %v", err)
+	}
+
+	boolCmd := NewCommand[NoDB](func(ctx *MsgContext, db *NoDB) {}, "bool", *NewCommandArg("flag").SetValueType(CommandValueBoolType).SetRequired())
+	if err := boolCmd.validateArgs([]string{"false"}); err != nil {
+		t.Fatalf("expected valid bool argument, got %v", err)
+	}
+	if err := boolCmd.validateArgs([]string{"falsey"}); !errors.Is(err, ErrCmdArgRegexpMismatch) {
+		t.Fatalf("expected ErrCmdArgRegexpMismatch for partial bool match, got %v", err)
+	}
+}

runners.go

@@ -0,0 +1,148 @@
+package laniakea
+
+import (
+	"context"
+	"time"
+)
+
+// RunnerFn is the function type for a runner. It receives a pointer to
+// the Bot and returns an error if execution fails.
+type RunnerFn[T DbContext] func(*Bot[T]) error
+
+// Runner represents a configurable background or one-time task to be
+// executed by a Bot.
+//
+// Runners are configured using builder methods: Onetime(), Async(), Timeout().
+// Once Execute() is called, the Runner should not be modified.
+//
+// Execution semantics:
+//   - onetime=true, async=false: Run once synchronously (blocks).
+//   - onetime=true, async=true:  Run once in a goroutine (non-blocking).
+//   - onetime=false, async=true: Run repeatedly in a goroutine with timeout.
+//   - onetime=false, async=false: Invalid configuration — ignored with warning.
+type Runner[T DbContext] struct {
+	name    string        // Human-readable name for logging
+	onetime bool          // If true, runs once; if false, runs periodically
+	async   bool          // If true, runs in a goroutine; else, runs synchronously
+	timeout time.Duration // Duration to wait between periodic executions (ignored if onetime=true)
+	fn      RunnerFn[T]   // The function to execute
+}
+
+// NewRunner creates a new Runner with the given name and function.
+// By default, the Runner is configured as async=true (non-blocking).
+//
+// Builder methods (Onetime, Async, Timeout) can be chained to customize behavior.
+// DO NOT call builder methods concurrently or after Execute().
+func NewRunner[T DbContext](name string, fn RunnerFn[T]) *Runner[T] {
+	return &Runner[T]{
+		name:    name,
+		fn:      fn,
+		async:   true, // Default: run asynchronously
+		timeout: 0,    // Default: no timeout (ignored if onetime=true)
+	}
+}
+
+// Onetime sets whether the runner executes once or repeatedly.
+// If true, the runner runs only once.
+// If false, the runner runs in a loop with the configured timeout.
+func (r *Runner[T]) Onetime(onetime bool) *Runner[T] {
+	r.onetime = onetime
+	return r
+}
+
+// Async sets whether the runner executes synchronously or asynchronously.
+// If true, the runner runs in a goroutine (non-blocking).
+// If false, the runner blocks the caller during execution.
+//
+// Note: If onetime=false and async=false, the runner will be skipped with a warning.
+func (r *Runner[T]) Async(async bool) *Runner[T] {
+	r.async = async
+	return r
+}
+
+// Timeout sets the duration to wait between repeated executions for
+// non-onetime runners.
+//
+// If onetime=true, this value is ignored.
+// If onetime=false and async=true, this timeout determines the sleep interval
+// between loop iterations.
+//
+// A zero value (time.Duration(0)) is allowed but may trigger a warning
+// if used with a background (non-onetime) async runner.
+func (r *Runner[T]) Timeout(timeout time.Duration) *Runner[T] {
+	r.timeout = timeout
+	return r
+}
+
+// ExecRunners executes all runners registered on the Bot with context-based lifecycle management.
+//
+// It logs warnings for misconfigured runners:
+//   - Sync, non-onetime runners are skipped (invalid configuration).
+//   - Background (non-onetime, async) runners without a timeout trigger a warning.
+//
+// Execution logic:
+//   - onetime + async: Runs once in a goroutine.
+//   - onetime + sync:  Runs once synchronously; warns if slower than 2 seconds.
+//   - !onetime + async: Runs in a loop with timeout between iterations until ctx.Done().
+//   - !onetime + sync: Skipped with warning.
+//
+// Background runners listen for ctx.Done() and gracefully shut down when the context is canceled.
+//
+// This method is typically called once during bot startup in RunWithContext.
+func (bot *Bot[T]) ExecRunners(ctx context.Context) {
+	bot.logger.Infoln("Executing runners...")
+	for _, runner := range bot.runners {
+		// Validate configuration
+		if !runner.onetime && !runner.async {
+			bot.logger.Warnf("Runner %s not onetime, but sync — skipping\n", runner.name)
+			continue
+		}
+		if !runner.onetime && runner.async && runner.timeout == 0 {
+			bot.logger.Warnf("Background runner \"%s\" has no timeout — skipping\n", runner.name)
+			continue
+		}
+
+		if runner.onetime && runner.async {
+			// One-time async: fire and forget
+			bot.runnerOnceWG.Add(1)
+			go func(r Runner[T]) {
+				defer bot.runnerOnceWG.Done()
+				err := r.fn(bot)
+				if err != nil {
+					bot.logger.Warnf("Runner %s failed: %s\n", r.name, err)
+				}
+			}(runner)
+		} else if runner.onetime && !runner.async {
+			// One-time sync: block until done
+			t := time.Now()
+			err := runner.fn(bot)
+			if err != nil {
+				bot.logger.Warnf("Runner %s failed: %s\n", runner.name, err)
+			}
+			elapsed := time.Since(t)
+			if elapsed > time.Second*2 {
+				bot.logger.Warnf("Runner %s too slow. Elapsed time %v >= 2s\n", runner.name, elapsed)
+			}
+		} else if !runner.onetime && runner.async {
+			// Background loop: periodic execution with graceful shutdown
+			bot.runnerBgWG.Add(1)
+			go func(r Runner[T]) {
+				defer bot.runnerBgWG.Done()
+				ticker := time.NewTicker(r.timeout)
+				defer ticker.Stop()
+				for {
+					select {
+					case <-ctx.Done():
+						return
+					case <-ticker.C:
+						err := r.fn(bot)
+						if err != nil {
+							bot.logger.Warnf("Runner %s failed: %s\n", r.name, err)
+						}
+					}
+				}
+			}(runner)
+		}
+		// Note: !onetime && !async is already skipped above
+	}
+}

tgapi/api.go

@@ -0,0 +1,316 @@
+package tgapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"git.nix13.pw/scuroneko/laniakea/utils"
+	"git.nix13.pw/scuroneko/slog"
+)
+
+// APIOpts holds configuration options for initializing the Telegram API client.
+// Use the provided setter methods to build options — do not construct directly.
+type APIOpts struct {
+	token         string
+	client        *http.Client
+	useTestServer bool
+	apiUrl        string
+
+	limiter           *utils.RateLimiter
+	dropOverflowLimit bool
+}
+
+// NewAPIOpts creates a new APIOpts with default values.
+// Use setter methods to customize behavior.
+func NewAPIOpts(token string) *APIOpts {
+	return &APIOpts{
+		token:         token,
+		client:        nil,
+		useTestServer: false,
+		apiUrl:        "https://api.telegram.org",
+	}
+}
+
+// SetHTTPClient sets a custom HTTP client. Use this for timeouts, proxies, or custom transport.
+// If not set, a default client with 45s timeout is used.
+func (opts *APIOpts) SetHTTPClient(client *http.Client) *APIOpts {
+	if client != nil {
+		opts.client = client
+	}
+	return opts
+}
+
+// UseTestServer enables use of Telegram's test server (https://api.test.telegram.org).
+// Only for development/testing.
+func (opts *APIOpts) UseTestServer(use bool) *APIOpts {
+	opts.useTestServer = use
+	return opts
+}
+
+// SetAPIUrl overrides the default Telegram API URL.
+// Useful for self-hosted bots or proxies.
+func (opts *APIOpts) SetAPIUrl(apiUrl string) *APIOpts {
+	if apiUrl != "" {
+		opts.apiUrl = apiUrl
+	}
+	return opts
+}
+
+// SetLimiter sets a rate limiter to enforce Telegram's API limits.
+// Recommended: use utils.NewRateLimiter() for correct per-chat and global throttling.
+func (opts *APIOpts) SetLimiter(limiter *utils.RateLimiter) *APIOpts {
+	opts.limiter = limiter
+	return opts
+}
+
+// SetLimiterDrop enables "drop mode" for rate limiting.
+// If true, requests exceeding limits return ErrDropOverflow immediately.
+// If false, requests block until capacity is available.
+func (opts *APIOpts) SetLimiterDrop(b bool) *APIOpts {
+	opts.dropOverflowLimit = b
+	return opts
+}
+
+// API is the main Telegram Bot API client for JSON requests.
+//
+// Use API methods when sending JSON payloads (for example with file_id, URL, or other
+// non-multipart fields). For multipart file uploads, use Uploader.
+//
+// It manages HTTP requests, rate limiting, retries, and connection pooling.
+type API struct {
+	token         string
+	client        *http.Client
+	logger        *slog.Logger
+	useTestServer bool
+	apiUrl        string
+
+	pool              *workerPool
+	Limiter           *utils.RateLimiter
+	dropOverflowLimit bool
+}
+
+// NewAPI creates a new API client from options.
+// Always call CloseApi() when done to release resources.
+func NewAPI(opts *APIOpts) *API {
+	l := slog.CreateLogger().Level(utils.GetLoggerLevel()).Prefix("API")
+	l.AddWriter(l.CreateJsonStdoutWriter())
+
+	client := opts.client
+	if client == nil {
+		client = &http.Client{Timeout: time.Second * 45}
+	}
+
+	pool := newWorkerPool(16, 256)
+	pool.start()
+
+	return &API{
+		token:             opts.token,
+		client:            client,
+		logger:            l,
+		useTestServer:     opts.useTestServer,
+		apiUrl:            opts.apiUrl,
+		pool:              pool,
+		Limiter:           opts.limiter,
+		dropOverflowLimit: opts.dropOverflowLimit,
+	}
+}
+
+// CloseApi shuts down the internal worker pool and closes the logger.
+// Must be called to avoid resource leaks.
+// See https://core.telegram.org/bots/api
+func (api *API) CloseApi() error {
+	api.pool.stop()
+	return api.logger.Close()
+}
+
+// GetLogger returns the internal logger for custom logging.
+// See https://core.telegram.org/bots/api
+func (api *API) GetLogger() *slog.Logger {
+	return api.logger
+}
+
+// ResponseParameters contains Telegram API response metadata (e.g., retry_after, migrate_to_chat_id).
+type ResponseParameters struct {
+	MigrateToChatID *int64 `json:"migrate_to_chat_id,omitempty"`
+	RetryAfter      *int   `json:"retry_after,omitempty"`
+}
+
+// ApiResponse is the standard Telegram Bot API response structure.
+// Generic over Result type R.
+type ApiResponse[R any] struct {
+	Ok          bool                `json:"ok"`
+	Description string              `json:"description,omitempty"`
+	Result      R                   `json:"result,omitempty"`
+	ErrorCode   int                 `json:"error_code,omitempty"`
+	Parameters  *ResponseParameters `json:"parameters,omitempty"`
+}
+
+// TelegramRequest is an internal helper struct.
+// DO NOT USE NewRequest or NewRequestWithChatID — they are unsafe and discouraged.
+// Instead, use explicit methods like SendMessage, GetUpdates, etc.
+//
+// Why? Because using generics with arbitrary types P and R leads to:
+//   - No compile-time validation of parameters
+//   - No IDE autocompletion
+//   - Runtime panics on malformed JSON
+//   - Hard-to-debug errors
+//
+// Recommended: Define specific methods for each Telegram method (see below).
+type TelegramRequest[R, P any] struct {
+	method string
+	params P
+	chatId int64
+}
+
+// NewRequest creates an untyped TelegramRequest for the given method and params with no chat ID.
+func NewRequest[R, P any](method string, params P) TelegramRequest[R, P] {
+	return TelegramRequest[R, P]{method, params, 0}
+}
+
+// NewRequestWithChatID creates an untyped TelegramRequest with an associated chat ID.
+// The chat ID is used for per-chat rate limiting.
+func NewRequestWithChatID[R, P any](method string, params P, chatId int64) TelegramRequest[R, P] {
+	return TelegramRequest[R, P]{method, params, chatId}
+}
+
+// doRequest performs a single HTTP request to Telegram API.
+// Handles rate limiting, retries on 429, and parses responses.
+// Must be called within a worker pool context if using DoWithContext.
+func (r TelegramRequest[R, P]) doRequest(ctx context.Context, api *API) (R, error) {
+	var zero R
+	reqData, err := json.Marshal(r.params)
+	if err != nil {
+		return zero, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	methodPrefix := ""
+	if api.useTestServer {
+		methodPrefix = "/test"
+	}
+	url := fmt.Sprintf("%s/bot%s%s/%s", api.apiUrl, api.token, methodPrefix, r.method)
+
+	req, err := http.NewRequestWithContext(ctx, "POST", url, nil)
+	if err != nil {
+		return zero, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", fmt.Sprintf("Laniakea/%s", utils.VersionString))
+
+	for {
+		// Apply rate limiting before making the request
+		if api.Limiter != nil {
+			if err := api.Limiter.Check(ctx, api.dropOverflowLimit, r.chatId); err != nil {
+				return zero, err
+			}
+		}
+		buf := bytes.NewBuffer(reqData)
+		req.Body = io.NopCloser(buf)
+		req.ContentLength = int64(len(reqData))
+
+		api.logger.Debugln("REQ", url, string(reqData))
+		resp, err := api.client.Do(req)
+		if err != nil {
+			return zero, fmt.Errorf("HTTP request failed: %w", err)
+		}
+
+		respData, err := readBody(resp.Body)
+		_ = resp.Body.Close() // ensure body is closed
+		if err != nil {
+			return zero, fmt.Errorf("failed to read response body: %w", err)
+		}
+
+		api.logger.Debugln("RES", r.method, string(respData))
+
+		response, err := parseBody[R](respData)
+		if err != nil {
+			return zero, fmt.Errorf("failed to parse response: %w", err)
+		}
+
+		if !response.Ok {
+			// Handle rate limiting (429)
+			if response.ErrorCode == 429 && response.Parameters != nil && response.Parameters.RetryAfter != nil {
+				after := *response.Parameters.RetryAfter
+				api.logger.Warnf("Rate limited by Telegram, retry after %d seconds (chat: %d)", after, r.chatId)
+
+				// Apply cooldown to global or chat-specific limiter
+				if api.Limiter != nil {
+					if r.chatId > 0 {
+						api.Limiter.SetChatLock(r.chatId, after)
+					} else {
+						api.Limiter.SetGlobalLock(after)
+					}
+				}
+
+				// Wait and retry
+				select {
+				case <-ctx.Done():
+					return zero, ctx.Err()
+				case <-time.After(time.Duration(after) * time.Second):
+					continue // retry request
+				}
+			}
+
+			// Other API errors
+			return zero, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description)
+		}
+
+		return response.Result, nil
+	}
+}
+
+// DoWithContext executes the request asynchronously via the worker pool.
+// Returns result or error via channel. Respects context cancellation.
+func (r TelegramRequest[R, P]) DoWithContext(ctx context.Context, api *API) (R, error) {
+	var zero R
+
+	resultChan, err := api.pool.submit(ctx, func(ctx context.Context) (any, error) {
+		return r.doRequest(ctx, api)
+	})
+	if err != nil {
+		return zero, err
+	}
+
+	select {
+	case <-ctx.Done():
+		return zero, ctx.Err()
+	case res := <-resultChan:
+		if res.err != nil {
+			return zero, res.err
+		}
+		if val, ok := res.value.(R); ok {
+			return val, nil
+		}
+		return zero, ErrPoolUnexpected
+	}
+}
+
+// Do executes the request synchronously with a background context.
+// Use only for simple, non-critical calls.
+func (r TelegramRequest[R, P]) Do(api *API) (R, error) {
+	return r.DoWithContext(context.Background(), api)
+}
+
+// readBody reads and limits response body to prevent memory exhaustion.
+// Telegram responses are typically small (<1MB), but we cap at 10MB.
+func readBody(body io.ReadCloser) ([]byte, error) {
+	reader := io.LimitReader(body, 10<<20) // 10 MB
+	return io.ReadAll(reader)
+}
+
+// parseBody unmarshals a Telegram API response into a typed ApiResponse.
+// Only returns an error on malformed JSON; non-OK responses are left for the caller to handle.
+func parseBody[R any](data []byte) (ApiResponse[R], error) {
+	var resp ApiResponse[R]
+	err := json.Unmarshal(data, &resp)
+	if err != nil {
+		return resp, fmt.Errorf("failed to unmarshal JSON: %w", err)
+	}
+	return resp, nil
+}

tgapi/api_test.go

@@ -0,0 +1,56 @@
+package tgapi
+
+import (
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return fn(req)
+}
+
+func TestAPILeavesAcceptEncodingToHTTPTransport(t *testing.T) {
+	var gotPath string
+	var gotAcceptEncoding string
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			gotPath = req.URL.Path
+			gotAcceptEncoding = req.Header.Get("Accept-Encoding")
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(`{"ok":true,"result":{"id":1,"is_bot":true,"first_name":"Test"}}`)),
+			}, nil
+		}),
+	}
+
+	api := NewAPI(
+		NewAPIOpts("token").
+			SetAPIUrl("https://example.test").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		if err := api.CloseApi(); err != nil {
+			t.Fatalf("CloseApi returned error: %v", err)
+		}
+	}()
+
+	user, err := api.GetMe()
+	if err != nil {
+		t.Fatalf("GetMe returned error: %v", err)
+	}
+	if user.FirstName != "Test" {
+		t.Fatalf("unexpected first name: %q", user.FirstName)
+	}
+	if gotPath != "/bottoken/getMe" {
+		t.Fatalf("unexpected request path: %s", gotPath)
+	}
+	if gotAcceptEncoding != "" {
+		t.Fatalf("expected empty Accept-Encoding header, got %q", gotAcceptEncoding)
+	}
+}

tgapi/attachments_methods.go

@@ -0,0 +1,282 @@
+package tgapi
+
+// SendPhotoP holds parameters for the sendPhoto method.
+// See https://core.telegram.org/bots/api#sendphoto
+type SendPhotoP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Photo           string          `json:"photo"`
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	ShowCaptionAboveMedia bool   `json:"show_caption_above_media,omitempty"`
+	HasSpoiler            bool   `json:"has_spoiler,omitempty"`
+	DisableNotifications  bool   `json:"disable_notification,omitempty"`
+	ProtectContent        bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendPhoto sends a photo.
+// See https://core.telegram.org/bots/api#sendphoto
+func (api *API) SendPhoto(params SendPhotoP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendPhoto", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendAudioP holds parameters for the sendAudio method.
+// See https://core.telegram.org/bots/api#sendaudio
+type SendAudioP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Audio           string          `json:"audio"`
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+	Duration        int             `json:"duration,omitempty"`
+	Performer       string          `json:"performer,omitempty"`
+	Title           string          `json:"title,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendAudio sends an audio file.
+// See https://core.telegram.org/bots/api#sendaudio
+func (api *API) SendAudio(params SendAudioP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendAudio", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendDocumentP holds parameters for the sendDocument method.
+// See https://core.telegram.org/bots/api#senddocument
+type SendDocumentP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Document        string          `json:"document"`
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendDocument sends a document.
+// See https://core.telegram.org/bots/api#senddocument
+func (api *API) SendDocument(params SendDocumentP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendDocument", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendVideoP holds parameters for the sendVideo method.
+// See https://core.telegram.org/bots/api#sendvideo
+type SendVideoP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Video    string `json:"video"`
+	Duration int    `json:"duration,omitempty"`
+	Width    int    `json:"width,omitempty"`
+	Height   int    `json:"height,omitempty"`
+	Cover    string `json:"cover,omitempty"`
+
+	StartTimestamp  int             `json:"start_timestamp,omitempty"`
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	ShowCaptionAboveMedia bool   `json:"show_caption_above_media,omitempty"`
+	HasSpoiler            bool   `json:"has_spoiler,omitempty"`
+	SupportsStreaming     bool   `json:"supports_streaming,omitempty"`
+	DisableNotification   bool   `json:"disable_notification,omitempty"`
+	ProtectContent        bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendVideo sends a video.
+// See https://core.telegram.org/bots/api#sendvideo
+func (api *API) SendVideo(params SendVideoP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendVideo", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendAnimationP holds parameters for the sendAnimation method.
+// See https://core.telegram.org/bots/api#sendanimation
+type SendAnimationP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Animation string `json:"animation"`
+	Duration  int    `json:"duration,omitempty"`
+	Width     int    `json:"width,omitempty"`
+	Height    int    `json:"height,omitempty"`
+
+	Caption               string          `json:"caption,omitempty"`
+	ParseMode             ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities       []MessageEntity `json:"caption_entities,omitempty"`
+	ShowCaptionAboveMedia bool            `json:"show_caption_above_media,omitempty"`
+	HasSpoiler            bool            `json:"has_spoiler,omitempty"`
+	DisableNotification   bool            `json:"disable_notification,omitempty"`
+	ProtectContent        bool            `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool            `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string          `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendAnimation sends an animation file (GIF or H.264/MPEG-4 AVC video without sound).
+// See https://core.telegram.org/bots/api#sendanimation
+func (api *API) SendAnimation(params SendAnimationP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendAnimation", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendVoiceP holds parameters for the sendVoice method.
+// See https://core.telegram.org/bots/api#sendvoice
+type SendVoiceP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Voice               string          `json:"voice"`
+	Caption             string          `json:"caption,omitempty"`
+	ParseMode           ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities     []MessageEntity `json:"caption_entities,omitempty"`
+	Duration            int             `json:"duration,omitempty"`
+	DisableNotification bool            `json:"disable_notification,omitempty"`
+	ProtectContent      bool            `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool            `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string          `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendVoice sends a voice note.
+// See https://core.telegram.org/bots/api#sendvoice
+func (api *API) SendVoice(params *SendVoiceP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendVoice", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendVideoNoteP holds parameters for the sendVideoNote method.
+// See https://core.telegram.org/bots/api#sendvideonote
+type SendVideoNoteP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	VideoNote           string `json:"video_note"`
+	Duration            int    `json:"duration,omitempty"`
+	Length              int    `json:"length,omitempty"`
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendVideoNote sends a video note (rounded video message).
+// See https://core.telegram.org/bots/api#sendvideonote
+func (api *API) SendVideoNote(params SendVideoNoteP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendVideoNote", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendPaidMediaP holds parameters for the sendPaidMedia method.
+// See https://core.telegram.org/bots/api#sendpaidmedia
+type SendPaidMediaP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+	StarCount             int    `json:"star_count,omitempty"`
+
+	Media                 []InputPaidMedia `json:"media"`
+	Payload               string           `json:"payload,omitempty"`
+	Caption               string           `json:"caption,omitempty"`
+	ParseMode             ParseMode        `json:"parse_mode,omitempty"`
+	CaptionEntities       []MessageEntity  `json:"caption_entities,omitempty"`
+	ShowCaptionAboveMedia bool             `json:"show_caption_above_media,omitempty"`
+	DisableNotification   bool             `json:"disable_notification,omitempty"`
+	ProtectContent        bool             `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool             `json:"allow_paid_broadcast,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendPaidMedia sends paid media.
+// See https://core.telegram.org/bots/api#sendpaidmedia
+func (api *API) SendPaidMedia(params SendPaidMediaP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendPaidMedia", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendMediaGroupP holds parameters for the sendMediaGroup method.
+// See https://core.telegram.org/bots/api#sendmediagroup
+type SendMediaGroupP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Media               []InputMedia     `json:"media"`
+	DisableNotification bool             `json:"disable_notification,omitempty"`
+	ProtectContent      bool             `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool             `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string           `json:"message_effect_id,omitempty"`
+	ReplyParameters     *ReplyParameters `json:"reply_parameters,omitempty"`
+}
+
+// SendMediaGroup sends a group of photos, videos, documents or audios as an album.
+// See https://core.telegram.org/bots/api#sendmediagroup
+func (api *API) SendMediaGroup(params SendMediaGroupP) ([]Message, error) {
+	req := NewRequestWithChatID[[]Message]("sendMediaGroup", params, params.ChatID)
+	return req.Do(api)
+}

tgapi/attachments_types.go

@@ -0,0 +1,74 @@
+package tgapi
+
+// InputMediaType represents the type of input media.
+type InputMediaType string
+
+const (
+	// InputMediaTypeAnimation is a GIF or H.264/MPEG-4 AVC video without sound.
+	InputMediaTypeAnimation InputMediaType = "animation"
+	// InputMediaTypeDocument is a general file.
+	InputMediaTypeDocument InputMediaType = "document"
+	// InputMediaTypePhoto is a photo.
+	InputMediaTypePhoto InputMediaType = "photo"
+	// InputMediaTypeVideo is a video.
+	InputMediaTypeVideo InputMediaType = "video"
+	// InputMediaTypeAudio is an audio file.
+	InputMediaTypeAudio InputMediaType = "audio"
+)
+
+// InputMedia represents the content of a media message to be sent.
+// It is a union type described in https://core.telegram.org/bots/api#inputmedia.
+type InputMedia struct {
+	Type  InputMediaType `json:"type"`
+	Media string         `json:"media"`
+
+	Caption               *string         `json:"caption,omitempty"`
+	ParseMode             *ParseMode      `json:"parse_mode,omitempty"`
+	CaptionEntities       []MessageEntity `json:"caption_entities,omitempty"`
+	ShowCaptionAboveMedia *bool           `json:"show_caption_above_media,omitempty"`
+	HasSpoiler            *bool           `json:"has_spoiler,omitempty"`
+
+	Cover             *string `json:"cover"`
+	StartTimestamp    *int    `json:"start_timestamp"`
+	Width             *int    `json:"width,omitempty"`
+	Height            *int    `json:"height,omitempty"`
+	Duration          *int    `json:"duration,omitempty"`
+	SupportsStreaming *bool   `json:"supports_streaming,omitempty"`
+
+	Performer *string `json:"performer,omitempty"`
+	Title     *string `json:"title,omitempty"`
+}
+
+// InputPaidMediaType represents the type of paid media.
+type InputPaidMediaType string
+
+const (
+	// InputPaidMediaTypeVideo represents a paid video.
+	InputPaidMediaTypeVideo InputPaidMediaType = "video"
+	// InputPaidMediaTypePhoto represents a paid photo.
+	InputPaidMediaTypePhoto InputPaidMediaType = "photo"
+)
+
+// InputPaidMedia describes the paid media to be sent.
+// See https://core.telegram.org/bots/api#inputpaidmedia
+type InputPaidMedia struct {
+	Type  InputPaidMediaType `json:"type"`
+	Media string             `json:"media"`
+
+	Cover             string `json:"cover"`
+	StartTimestamp    int64  `json:"start_timestamp"`
+	Width             int    `json:"width"`
+	Height            int    `json:"height"`
+	Duration          int    `json:"duration"`
+	SupportsStreaming bool   `json:"supports_streaming"`
+}
+
+// PhotoSize represents one size of a photo or a file/sticker thumbnail.
+// See https://core.telegram.org/bots/api#photosize
+type PhotoSize struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	Width        int    `json:"width"`
+	Height       int    `json:"height"`
+	FileSize     int64  `json:"file_size,omitempty"`
+}

tgapi/bot_methods.go

@@ -0,0 +1,254 @@
+package tgapi
+
+// SetMyCommandsP holds parameters for the setMyCommands method.
+// See https://core.telegram.org/bots/api#setmycommands
+type SetMyCommandsP struct {
+	Commands []BotCommand     `json:"commands"`
+	Scope    *BotCommandScope `json:"scope,omitempty"`
+	Language string           `json:"language_code,omitempty"`
+}
+
+// SetMyCommands changes the list of the bot's commands.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setmycommands
+func (api *API) SetMyCommands(params SetMyCommandsP) (bool, error) {
+	req := NewRequest[bool]("setMyCommands", params)
+	return req.Do(api)
+}
+
+// DeleteMyCommandsP holds parameters for the deleteMyCommands method.
+// See https://core.telegram.org/bots/api#deletemycommands
+type DeleteMyCommandsP struct {
+	Scope    *BotCommandScope `json:"scope,omitempty"`
+	Language string           `json:"language_code,omitempty"`
+}
+
+// DeleteMyCommands deletes the list of the bot's commands for the given scope and user language.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#deletemycommands
+func (api *API) DeleteMyCommands(params DeleteMyCommandsP) (bool, error) {
+	req := NewRequest[bool]("deleteMyCommands", params)
+	return req.Do(api)
+}
+
+// GetMyCommands holds parameters for the getMyCommands method.
+// See https://core.telegram.org/bots/api#getmycommands
+type GetMyCommands struct {
+	Scope    *BotCommandScope `json:"scope,omitempty"`
+	Language string           `json:"language_code,omitempty"`
+}
+
+// GetMyCommands returns the current list of the bot's commands for the given scope and user language.
+// See https://core.telegram.org/bots/api#getmycommands
+func (api *API) GetMyCommands(params GetMyCommands) ([]BotCommand, error) {
+	req := NewRequest[[]BotCommand]("getMyCommands", params)
+	return req.Do(api)
+}
+
+// SetMyName holds parameters for the setMyName method.
+// See https://core.telegram.org/bots/api#setmyname
+type SetMyName struct {
+	Name     string `json:"name"`
+	Language string `json:"language_code,omitempty"`
+}
+
+// SetMyName changes the bot's name.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setmyname
+func (api *API) SetMyName(params SetMyName) (bool, error) {
+	req := NewRequest[bool]("setMyName", params)
+	return req.Do(api)
+}
+
+// GetMyName holds parameters for the getMyName method.
+// See https://core.telegram.org/bots/api#getmyname
+type GetMyName struct {
+	Language string `json:"language_code,omitempty"`
+}
+
+// GetMyName returns the bot's name for the given language.
+// See https://core.telegram.org/bots/api#getmyname
+func (api *API) GetMyName(params GetMyName) (BotName, error) {
+	req := NewRequest[BotName]("getMyName", params)
+	return req.Do(api)
+}
+
+// SetMyDescription holds parameters for the setMyDescription method.
+// See https://core.telegram.org/bots/api#setmydescription
+type SetMyDescription struct {
+	Description string `json:"description"`
+	Language    string `json:"language_code,omitempty"`
+}
+
+// SetMyDescription changes the bot's description.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setmydescription
+func (api *API) SetMyDescription(params SetMyDescription) (bool, error) {
+	req := NewRequest[bool]("setMyDescription", params)
+	return req.Do(api)
+}
+
+// GetMyDescription holds parameters for the getMyDescription method.
+// See https://core.telegram.org/bots/api#getmydescription
+type GetMyDescription struct {
+	Language string `json:"language_code,omitempty"`
+}
+
+// GetMyDescription returns the bot's description for the given language.
+// See https://core.telegram.org/bots/api#getmydescription
+func (api *API) GetMyDescription(params GetMyDescription) (BotDescription, error) {
+	req := NewRequest[BotDescription]("getMyDescription", params)
+	return req.Do(api)
+}
+
+// SetMyShortDescription holds parameters for the setMyShortDescription method.
+// See https://core.telegram.org/bots/api#setmyshortdescription
+type SetMyShortDescription struct {
+	ShortDescription string `json:"short_description,omitempty"`
+	Language         string `json:"language_code,omitempty"`
+}
+
+// SetMyShortDescription changes the bot's short description.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setmyshortdescription
+func (api *API) SetMyShortDescription(params SetMyShortDescription) (bool, error) {
+	req := NewRequest[bool]("setMyShortDescription", params)
+	return req.Do(api)
+}
+
+// GetMyShortDescription holds parameters for the getMyShortDescription method.
+// See https://core.telegram.org/bots/api#getmyshortdescription
+type GetMyShortDescription struct {
+	Language string `json:"language_code,omitempty"`
+}
+
+// GetMyShortDescription returns the bot's short description for the given language.
+// See https://core.telegram.org/bots/api#getmyshortdescription
+func (api *API) GetMyShortDescription(params GetMyShortDescription) (BotShortDescription, error) {
+	req := NewRequest[BotShortDescription]("getMyShortDescription", params)
+	return req.Do(api)
+}
+
+// SetMyProfilePhotoP holds parameters for the setMyProfilePhoto method.
+// See https://core.telegram.org/bots/api#setmyprofilephoto
+type SetMyProfilePhotoP struct {
+	Photo InputProfilePhoto `json:"photo"`
+}
+
+// SetMyProfilePhoto changes the bot's profile photo.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setmyprofilephoto
+func (api *API) SetMyProfilePhoto(params SetMyProfilePhotoP) (bool, error) {
+	req := NewRequest[bool]("setMyProfilePhoto", params)
+	return req.Do(api)
+}
+
+// RemoveMyProfilePhoto removes the bot's profile photo.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#removemyprofilephoto
+func (api *API) RemoveMyProfilePhoto() (bool, error) {
+	req := NewRequest[bool]("removeMyProfilePhoto", NoParams)
+	return req.Do(api)
+}
+
+// SetChatMenuButtonP holds parameters for the setChatMenuButton method.
+// See https://core.telegram.org/bots/api#setchatmenubutton
+type SetChatMenuButtonP struct {
+	ChatID     int64          `json:"chat_id"`
+	MenuButton MenuButtonType `json:"menu_button"`
+}
+
+// SetChatMenuButton changes the menu button for a given chat or the default menu button.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setchatmenubutton
+func (api *API) SetChatMenuButton(params SetChatMenuButtonP) (bool, error) {
+	req := NewRequest[bool]("setChatMenuButton", params)
+	return req.Do(api)
+}
+
+// GetChatMenuButtonP holds parameters for the getChatMenuButton method.
+// See https://core.telegram.org/bots/api#getchatmenubutton
+type GetChatMenuButtonP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// GetChatMenuButton returns the current menu button for the given chat.
+// See https://core.telegram.org/bots/api#getchatmenubutton
+func (api *API) GetChatMenuButton(params GetChatMenuButtonP) (BaseMenuButton, error) {
+	req := NewRequest[BaseMenuButton]("getChatMenuButton", params)
+	return req.Do(api)
+}
+
+// SetMyDefaultAdministratorRightsP holds parameters for the setMyDefaultAdministratorRights method.
+// See https://core.telegram.org/bots/api#setmydefaultadministratorrights
+type SetMyDefaultAdministratorRightsP struct {
+	Rights      *ChatAdministratorRights `json:"rights"`
+	ForChannels bool                     `json:"for_channels"`
+}
+
+// SetMyDefaultAdministratorRights changes the default administrator rights for the bot.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setmydefaultadministratorrights
+func (api *API) SetMyDefaultAdministratorRights(params SetMyDefaultAdministratorRightsP) (bool, error) {
+	req := NewRequest[bool]("setMyDefaultAdministratorRights", params)
+	return req.Do(api)
+}
+
+// GetMyDefaultAdministratorRightsP holds parameters for the getMyDefaultAdministratorRights method.
+// See https://core.telegram.org/bots/api#getmydefaultadministratorrights
+type GetMyDefaultAdministratorRightsP struct {
+	ForChannels bool `json:"for_channels"`
+}
+
+// GetMyDefaultAdministratorRights returns the current default administrator rights for the bot.
+// See https://core.telegram.org/bots/api#getmydefaultadministratorrights
+func (api *API) GetMyDefaultAdministratorRights(params GetMyDefaultAdministratorRightsP) (ChatAdministratorRights, error) {
+	req := NewRequest[ChatAdministratorRights]("getMyDefaultAdministratorRights", params)
+	return req.Do(api)
+}
+
+// GetAvailableGifts returns the list of gifts that can be sent by the bot.
+// See https://core.telegram.org/bots/api#getavailablegifts
+func (api *API) GetAvailableGifts() (Gifts, error) {
+	req := NewRequest[Gifts]("getAvailableGifts", NoParams)
+	return req.Do(api)
+}
+
+// SendGiftP holds parameters for the sendGift method.
+// See https://core.telegram.org/bots/api#sendgift
+type SendGiftP struct {
+	UserID        int64           `json:"user_id,omitempty"`
+	ChatID        int64           `json:"chat_id,omitempty"`
+	GiftID        string          `json:"gift_id"`
+	PayForUpgrade bool            `json:"pay_for_upgrade"`
+	Text          string          `json:"text"`
+	TextParseMode ParseMode       `json:"text_parse_mode,omitempty"`
+	TextEntities  []MessageEntity `json:"text_entities,omitempty"`
+}
+
+// SendGift sends a gift to the given user or chat.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#sendgift
+func (api *API) SendGift(params SendGiftP) (bool, error) {
+	req := NewRequest[bool]("sendGift", params)
+	return req.Do(api)
+}
+
+// GiftPremiumSubscriptionP holds parameters for the giftPremiumSubscription method.
+// See https://core.telegram.org/bots/api#giftpremiumsubscription
+type GiftPremiumSubscriptionP struct {
+	UserID        int64           `json:"user_id"`
+	MonthCount    int             `json:"month_count"`
+	StarCount     int             `json:"star_count"`
+	Text          string          `json:"text,omitempty"`
+	TextParseMode ParseMode       `json:"text_parse_mode,omitempty"`
+	TextEntities  []MessageEntity `json:"text_entities,omitempty"`
+}
+
+// GiftPremiumSubscription gifts a Telegram Premium subscription to the user.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#giftpremiumsubscription
+func (api *API) GiftPremiumSubscription(params GiftPremiumSubscriptionP) (bool, error) {
+	req := NewRequest[bool]("giftPremiumSubscription", params)
+	return req.Do(api)
+}

tgapi/bot_types.go

@@ -0,0 +1,91 @@
+package tgapi
+
+// BotCommand represents a bot command.
+// See https://core.telegram.org/bots/api#botcommand
+type BotCommand struct {
+	Command     string `json:"command"`
+	Description string `json:"description"`
+}
+
+// BotCommandScopeType indicates the type of a command scope.
+type BotCommandScopeType string
+
+const (
+	// BotCommandScopeDefaultType is the default command scope.
+	BotCommandScopeDefaultType BotCommandScopeType = "default"
+	// BotCommandScopePrivateType covers all private chats.
+	BotCommandScopePrivateType BotCommandScopeType = "all_private_chats"
+	// BotCommandScopeGroupType covers all group and supergroup chats.
+	BotCommandScopeGroupType BotCommandScopeType = "all_group_chats"
+	// BotCommandScopeAllChatAdministratorsType covers all chat administrators.
+	BotCommandScopeAllChatAdministratorsType BotCommandScopeType = "all_chat_administrators"
+	// BotCommandScopeChatType covers a specific chat.
+	BotCommandScopeChatType BotCommandScopeType = "chat"
+	// BotCommandScopeChatAdministratorsType covers administrators of a specific chat.
+	BotCommandScopeChatAdministratorsType BotCommandScopeType = "chat_administrators"
+	// BotCommandScopeChatMemberType covers a specific member of a specific chat.
+	BotCommandScopeChatMemberType BotCommandScopeType = "chat_member"
+)
+
+// BotCommandScope represents the scope to which bot commands are applied.
+// See https://core.telegram.org/bots/api#botcommandscope
+type BotCommandScope struct {
+	Type   BotCommandScopeType `json:"type"`
+	ChatID *int64              `json:"chat_id,omitempty"`
+	UserID *int64              `json:"user_id,omitempty"`
+}
+
+// BotName represents the bot's name.
+type BotName struct {
+	Name string `json:"name"`
+}
+
+// BotDescription represents the bot's description.
+type BotDescription struct {
+	Description string `json:"description"`
+}
+
+// BotShortDescription represents the bot's short description.
+type BotShortDescription struct {
+	ShortDescription string `json:"short_description"`
+}
+
+// InputProfilePhotoType indicates the type of a profile photo input.
+type InputProfilePhotoType string
+
+const (
+	InputProfilePhotoStaticType   InputProfilePhotoType = "static"
+	InputProfilePhotoAnimatedType InputProfilePhotoType = "animated"
+)
+
+// InputProfilePhoto describes a profile photo to set.
+// See https://core.telegram.org/bots/api#inputprofilephoto
+type InputProfilePhoto struct {
+	Type InputProfilePhotoType `json:"type"`
+
+	// Static fields (for static photos)
+	Photo *string `json:"photo,omitempty"`
+
+	// Animated fields (for animated profile videos)
+	Animation          *string  `json:"animation,omitempty"`
+	MainFrameTimestamp *float64 `json:"main_frame_timestamp,omitempty"`
+}
+
+// MenuButtonType indicates the type of a menu button.
+type MenuButtonType string
+
+const (
+	MenuButtonCommandsType MenuButtonType = "commands"
+	MenuButtonWebAppType   MenuButtonType = "web_app"
+	MenuButtonDefaultType  MenuButtonType = "default"
+)
+
+// BaseMenuButton represents a menu button.
+// See https://core.telegram.org/bots/api#menubutton
+type BaseMenuButton struct {
+	Type MenuButtonType `json:"type"`
+
+	// WebApp fields (for web_app button)
+	Text   string     `json:"text"`
+	WebApp WebAppInfo `json:"web_app"`
+}

tgapi/business_methods.go

@@ -0,0 +1,381 @@
+package tgapi
+
+// VerifyUserP holds parameters for the verifyUser method.
+// See https://core.telegram.org/bots/api#verifyuser
+type VerifyUserP struct {
+	UserID            int64  `json:"user_id"`
+	CustomDescription string `json:"custom_description,omitempty"`
+}
+
+// VerifyUser verifies a user.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#verifyuser
+func (api *API) VerifyUser(params VerifyUserP) (bool, error) {
+	req := NewRequest[bool]("verifyUser", params)
+	return req.Do(api)
+}
+
+// VerifyChatP holds parameters for the verifyChat method.
+// See https://core.telegram.org/bots/api#verifychat
+type VerifyChatP struct {
+	ChatID            int64  `json:"chat_id"`
+	CustomDescription string `json:"custom_description,omitempty"`
+}
+
+// VerifyChat verifies a chat.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#verifychat
+func (api *API) VerifyChat(params VerifyChatP) (bool, error) {
+	req := NewRequest[bool]("verifyChat", params)
+	return req.Do(api)
+}
+
+// RemoveUserVerificationP holds parameters for the removeUserVerification method.
+// See https://core.telegram.org/bots/api#removeuserverification
+type RemoveUserVerificationP struct {
+	UserID int64 `json:"user_id"`
+}
+
+// RemoveUserVerification removes a user's verification.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#removeuserverification
+func (api *API) RemoveUserVerification(params RemoveUserVerificationP) (bool, error) {
+	req := NewRequest[bool]("removeUserVerification", params)
+	return req.Do(api)
+}
+
+// RemoveChatVerificationP holds parameters for the removeChatVerification method.
+// See https://core.telegram.org/bots/api#removechatverification
+type RemoveChatVerificationP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// RemoveChatVerification removes a chat's verification.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#removechatverification
+func (api *API) RemoveChatVerification(params RemoveChatVerificationP) (bool, error) {
+	req := NewRequest[bool]("removeChatVerification", params)
+	return req.Do(api)
+}
+
+// ReadBusinessMessageP holds parameters for the readBusinessMessage method.
+// See https://core.telegram.org/bots/api#readbusinessmessage
+type ReadBusinessMessageP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	ChatID               int64  `json:"chat_id"`
+	MessageID            int    `json:"message_id"`
+}
+
+// ReadBusinessMessage marks a business message as read.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#readbusinessmessage
+func (api *API) ReadBusinessMessage(params ReadBusinessMessageP) (bool, error) {
+	req := NewRequest[bool]("readBusinessMessage", params)
+	return req.Do(api)
+}
+
+// GetBusinessConnectionP holds parameters for the getBusinessConnection method.
+// See https://core.telegram.org/bots/api#getbusinessconnection
+type GetBusinessConnectionP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+}
+
+// GetBusinessConnection returns information about a business connection.
+// See https://core.telegram.org/bots/api#getbusinessconnection
+func (api *API) GetBusinessConnection(params GetBusinessConnectionP) (BusinessConnection, error) {
+	req := NewRequest[BusinessConnection]("getBusinessConnection", params)
+	return req.Do(api)
+}
+
+// DeleteBusinessMessagesP holds parameters for the deleteBusinessMessages method.
+// See https://core.telegram.org/bots/api#deletebusinessmessages
+type DeleteBusinessMessagesP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	MessageIDs           []int  `json:"message_ids"`
+}
+
+// DeleteBusinessMessages deletes business messages.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#deletebusinessmessages
+func (api *API) DeleteBusinessMessages(params DeleteBusinessMessagesP) (bool, error) {
+	req := NewRequest[bool]("deleteBusinessMessages", params)
+	return req.Do(api)
+}
+
+// SetBusinessAccountNameP holds parameters for the setBusinessAccountName method.
+// See https://core.telegram.org/bots/api#setbusinessaccountname
+type SetBusinessAccountNameP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	FirstName            string `json:"first_name"`
+	LastName             string `json:"last_name,omitempty"`
+}
+
+// SetBusinessAccountName sets the first and last name of a business account.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setbusinessaccountname
+func (api *API) SetBusinessAccountName(params SetBusinessAccountNameP) (bool, error) {
+	req := NewRequest[bool]("setBusinessAccountName", params)
+	return req.Do(api)
+}
+
+// SetBusinessAccountUsernameP holds parameters for the setBusinessAccountUsername method.
+// See https://core.telegram.org/bots/api#setbusinessaccountusername
+type SetBusinessAccountUsernameP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	Username             string `json:"username,omitempty"`
+}
+
+// SetBusinessAccountUsername sets the username of a business account.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setbusinessaccountusername
+func (api *API) SetBusinessAccountUsername(params SetBusinessAccountUsernameP) (bool, error) {
+	req := NewRequest[bool]("setBusinessAccountUsername", params)
+	return req.Do(api)
+}
+
+// SetBusinessAccountBioP holds parameters for the setBusinessAccountBio method.
+// See https://core.telegram.org/bots/api#setbusinessaccountbio
+type SetBusinessAccountBioP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	Bio                  string `json:"bio,omitempty"`
+}
+
+// SetBusinessAccountBio sets the bio of a business account.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setbusinessaccountbio
+func (api *API) SetBusinessAccountBio(params SetBusinessAccountBioP) (bool, error) {
+	req := NewRequest[bool]("setBusinessAccountBio", params)
+	return req.Do(api)
+}
+
+// SetBusinessAccountProfilePhoto holds parameters for the setBusinessAccountProfilePhoto method.
+// See https://core.telegram.org/bots/api#setbusinessaccountprofilephoto
+type SetBusinessAccountProfilePhoto struct {
+	BusinessConnectionID string            `json:"business_connection_id"`
+	Photo                InputProfilePhoto `json:"photo,omitempty"`
+	IsPublic             bool              `json:"is_public,omitempty"`
+}
+
+// SetBusinessAccountProfilePhoto sets the profile photo of a business account.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setbusinessaccountprofilephoto
+func (api *API) SetBusinessAccountProfilePhoto(params SetBusinessAccountProfilePhoto) (bool, error) {
+	req := NewRequest[bool]("setBusinessAccountProfilePhoto", params)
+	return req.Do(api)
+}
+
+// RemoveBusinessAccountProfilePhotoP holds parameters for the removeBusinessAccountProfilePhoto method.
+// See https://core.telegram.org/bots/api#removebusinessaccountprofilephoto
+type RemoveBusinessAccountProfilePhotoP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	IsPublic             bool   `json:"is_public,omitempty"`
+}
+
+// RemoveBusinessAccountProfilePhoto removes the profile photo of a business account.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#removebusinessaccountprofilephoto
+func (api *API) RemoveBusinessAccountProfilePhoto(params RemoveBusinessAccountProfilePhotoP) (bool, error) {
+	req := NewRequest[bool]("removeBusinessAccountProfilePhoto", params)
+	return req.Do(api)
+}
+
+// SetBusinessAccountGiftSettingsP holds parameters for the setBusinessAccountGiftSettings method.
+// See https://core.telegram.org/bots/api#setbusinessaccountgiftsettings
+type SetBusinessAccountGiftSettingsP struct {
+	BusinessConnectionID string            `json:"business_connection_id"`
+	ShowGiftButton       bool              `json:"show_gift_button"`
+	AcceptedGiftTypes    AcceptedGiftTypes `json:"accepted_gift_types"`
+}
+
+// SetBusinessAccountGiftSettings sets gift settings for a business account.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setbusinessaccountgiftsettings
+func (api *API) SetBusinessAccountGiftSettings(params SetBusinessAccountGiftSettingsP) (bool, error) {
+	req := NewRequest[bool]("setBusinessAccountGiftSettings", params)
+	return req.Do(api)
+}
+
+// GetBusinessAccountStarBalanceP holds parameters for the getBusinessAccountStarBalance method.
+// See https://core.telegram.org/bots/api#getbusinessaccountstarbalance
+type GetBusinessAccountStarBalanceP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+}
+
+// GetBusinessAccountStarBalance returns the star balance of a business account.
+// See https://core.telegram.org/bots/api#getbusinessaccountstarbalance
+func (api *API) GetBusinessAccountStarBalance(params GetBusinessAccountStarBalanceP) (StarAmount, error) {
+	req := NewRequest[StarAmount]("getBusinessAccountStarBalance", params)
+	return req.Do(api)
+}
+
+// TransferBusinessAccountStarsP holds parameters for the transferBusinessAccountStars method.
+// See https://core.telegram.org/bots/api#transferbusinessaccountstars
+type TransferBusinessAccountStarsP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	StarCount            int    `json:"star_count"`
+}
+
+// TransferBusinessAccountStars transfers stars from a business account.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#transferbusinessaccountstars
+func (api *API) TransferBusinessAccountStars(params TransferBusinessAccountStarsP) (bool, error) {
+	req := NewRequest[bool]("transferBusinessAccountStars", params)
+	return req.Do(api)
+}
+
+// GetBusinessAccountGiftsP holds parameters for the getBusinessAccountGifts method.
+// See https://core.telegram.org/bots/api#getbusinessaccountgifts
+type GetBusinessAccountGiftsP struct {
+	BusinessConnectionID        string `json:"business_connection_id"`
+	ExcludeUnsaved              bool   `json:"exclude_unsaved,omitempty"`
+	ExcludeSaved                bool   `json:"exclude_saved,omitempty"`
+	ExcludeUnlimited            bool   `json:"exclude_unlimited,omitempty"`
+	ExcludeLimitedUpgradable    bool   `json:"exclude_limited_upgradable,omitempty"`
+	ExcludeLimitedNonUpgradable bool   `json:"exclude_limited_non_upgradable,omitempty"`
+	ExcludeUnique               bool   `json:"exclude_unique,omitempty"`
+	ExcludeFromBlockchain       bool   `json:"exclude_from_blockchain,omitempty"`
+	SortByPrice                 bool   `json:"sort_by_price,omitempty"`
+	Offset                      string `json:"offset,omitempty"`
+	Limit                       int    `json:"limit,omitempty"`
+}
+
+// GetBusinessAccountGifts returns gifts owned by a business account.
+// See https://core.telegram.org/bots/api#getbusinessaccountgifts
+func (api *API) GetBusinessAccountGifts(params GetBusinessAccountGiftsP) (OwnedGifts, error) {
+	req := NewRequest[OwnedGifts]("getBusinessAccountGifts", params)
+	return req.Do(api)
+}
+
+// ConvertGiftToStarsP holds parameters for the convertGiftToStars method.
+// See https://core.telegram.org/bots/api#convertgifttostars
+type ConvertGiftToStarsP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	OwnedGiftID          string `json:"owned_gift_id"`
+}
+
+// ConvertGiftToStars converts a gift to Telegram Stars.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#convertgifttostars
+func (api *API) ConvertGiftToStars(params ConvertGiftToStarsP) (bool, error) {
+	req := NewRequest[bool]("convertGiftToStars", params)
+	return req.Do(api)
+}
+
+// UpgradeGiftP holds parameters for the upgradeGift method.
+// See https://core.telegram.org/bots/api#upgradegift
+type UpgradeGiftP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	OwnedGiftID          string `json:"owned_gift_id"`
+	KeepOriginalDetails  bool   `json:"keep_original_details,omitempty"`
+	StarCount            int    `json:"star_count,omitempty"`
+}
+
+// UpgradeGift upgrades a gift.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#upgradegift
+func (api *API) UpgradeGift(params UpgradeGiftP) (bool, error) {
+	req := NewRequest[bool]("upgradeGift", params)
+	return req.Do(api)
+}
+
+// TransferGiftP holds parameters for the transferGift method.
+// See https://core.telegram.org/bots/api#transfergift
+type TransferGiftP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	OwnedGiftID          string `json:"owned_gift_id"`
+	NewOwnerChatID       int64  `json:"new_owner_chat_id"`
+	StarCount            int    `json:"star_count,omitempty"`
+}
+
+// TransferGift transfers a gift to another chat.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#transfergift
+func (api *API) TransferGift(params TransferGiftP) (bool, error) {
+	req := NewRequest[bool]("transferGift", params)
+	return req.Do(api)
+}
+
+// PostStoryP holds parameters for the postStory method.
+// See https://core.telegram.org/bots/api#poststory
+type PostStoryP struct {
+	BusinessConnectionID string            `json:"business_connection_id"`
+	Content              InputStoryContent `json:"content"`
+	ActivePeriod         int               `json:"active_period"`
+
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+	Areas           []StoryArea     `json:"areas"`
+
+	PostToChatPage bool `json:"post_to_chat_page,omitempty"`
+	ProtectContent bool `json:"protect_content,omitempty"`
+}
+
+// PostStoryPhoto posts a story with a photo.
+// See https://core.telegram.org/bots/api#poststory
+func (api *API) PostStoryPhoto(params PostStoryP) (Story, error) {
+	req := NewRequest[Story]("postStory", params)
+	return req.Do(api)
+}
+
+// PostStoryVideo posts a story with a video.
+// See https://core.telegram.org/bots/api#poststory
+func (api *API) PostStoryVideo(params PostStoryP) (Story, error) {
+	req := NewRequest[Story]("postStory", params)
+	return req.Do(api)
+}
+
+// RepostStoryP holds parameters for the repostStory method.
+// See https://core.telegram.org/bots/api#repoststory
+type RepostStoryP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	FromChatID           int64  `json:"from_chat_id"`
+	FromStoryID          int    `json:"from_story_id"`
+	ActivePeriod         int    `json:"active_period"`
+	PostToChatPage       bool   `json:"post_to_chat_page,omitempty"`
+	ProtectContent       bool   `json:"protect_content,omitempty"`
+}
+
+// RepostStory reposts a story from another chat.
+// Returns the reposted story.
+// See https://core.telegram.org/bots/api#repoststory
+func (api *API) RepostStory(params RepostStoryP) (Story, error) {
+	req := NewRequest[Story]("repostStory", params)
+	return req.Do(api)
+}
+
+// EditStoryP holds parameters for the editStory method.
+// See https://core.telegram.org/bots/api#editstory
+type EditStoryP struct {
+	BusinessConnectionID string            `json:"business_connection_id"`
+	StoryID              int               `json:"story_id"`
+	Content              InputStoryContent `json:"content"`
+
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+	Areas           []StoryArea     `json:"areas,omitempty"`
+}
+
+// EditStory edits an existing story.
+// Returns the updated story.
+// See https://core.telegram.org/bots/api#editstory
+func (api *API) EditStory(params EditStoryP) (Story, error) {
+	req := NewRequest[Story]("editStory", params)
+	return req.Do(api)
+}
+
+// DeleteStoryP holds parameters for the deleteStory method.
+// See https://core.telegram.org/bots/api#deletestory
+type DeleteStoryP struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	StoryID              int    `json:"story_id"`
+}
+
+// DeleteStory deletes a story.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#deletestory
+func (api *API) DeleteStory(params DeleteStoryP) (bool, error) {
+	req := NewRequest[bool]("deleteStory", params)
+	return req.Do(api)
+}

tgapi/business_types.go

@@ -0,0 +1,149 @@
+package tgapi
+
+// BusinessIntro contains information about the business intro.
+// See https://core.telegram.org/bots/api#businessintro
+type BusinessIntro struct {
+	Title   string   `json:"title,omitempty"`
+	Message string   `json:"message,omitempty"`
+	Sticker *Sticker `json:"sticker,omitempty"`
+}
+
+// BusinessLocation contains information about the business location.
+// See https://core.telegram.org/bots/api#businesslocation
+type BusinessLocation struct {
+	Address  string    `json:"address"`
+	Location *Location `json:"location,omitempty"`
+}
+
+// BusinessOpeningHoursInterval represents an interval of opening hours.
+// See https://core.telegram.org/bots/api#businessopeninghoursinterval
+type BusinessOpeningHoursInterval struct {
+	OpeningMinute int `json:"opening_minute"`
+	ClosingMinute int `json:"closing_minute"`
+}
+
+// BusinessOpeningHours represents the opening hours of a business.
+// See https://core.telegram.org/bots/api#businessopeninghours
+type BusinessOpeningHours struct {
+	TimeZoneName string                         `json:"time_zone_name"`
+	OpeningHours []BusinessOpeningHoursInterval `json:"opening_hours"`
+}
+
+// BusinessBotRights represents the rights of a business bot.
+// All fields are optional booleans that, when present, are always true.
+// See https://core.telegram.org/bots/api#businessbotrights
+type BusinessBotRights struct {
+	CanReply                   *bool `json:"can_reply,omitempty"`
+	CanReadMessages            *bool `json:"can_read_messages,omitempty"`
+	CanDeleteSentMessages      *bool `json:"can_delete_sent_messages,omitempty"`
+	CanDeleteAllMessages       *bool `json:"can_delete_all_messages,omitempty"`
+	CanEditName                *bool `json:"can_edit_name,omitempty"`
+	CanEditBio                 *bool `json:"can_edit_bio,omitempty"`
+	CanEditProfilePhoto        *bool `json:"can_edit_profile_photo,omitempty"`
+	CanEditUsername            *bool `json:"can_edit_username,omitempty"`
+	CanChangeGiftSettings      *bool `json:"can_change_gift_settings,omitempty"`
+	CanViewGiftsAndStars       *bool `json:"can_view_gifts_and_stars,omitempty"`
+	CanConvertGiftsToStars     *bool `json:"can_convert_gifts_to_stars,omitempty"`
+	CanTransferAndUpgradeGifts *bool `json:"can_transfer_and_upgrade_gifts,omitempty"`
+	CanTransferStars           *bool `json:"can_transfer_stars,omitempty"`
+	CanManageStories           *bool `json:"can_manage_stories,omitempty"`
+}
+
+// BusinessConnection contains information about a business connection.
+// See https://core.telegram.org/bots/api#businessconnection
+type BusinessConnection struct {
+	ID         string             `json:"id"`
+	User       User               `json:"user"`
+	UserChatID int64              `json:"user_chat_id"`
+	Date       int                `json:"date"`
+	Rights     *BusinessBotRights `json:"rights,omitempty"`
+	IsEnabled  bool               `json:"is_enabled"`
+}
+
+// BusinessMessagesDeleted is received when messages are deleted from a connected business account.
+// See https://core.telegram.org/bots/api#businessmessagesdeleted
+type BusinessMessagesDeleted struct {
+	BusinessConnectionID string `json:"business_connection_id"`
+	Chat                 Chat   `json:"chat"`
+	MessageIDs           []int  `json:"message_ids"`
+}
+
+// InputStoryContentType indicates the type of input story content.
+type InputStoryContentType string
+
+const (
+	InputStoryContentPhotoType InputStoryContentType = "photo"
+	InputStoryContentVideoType InputStoryContentType = "video"
+)
+
+// InputStoryContent represents the content of a story to be posted.
+// See https://core.telegram.org/bots/api#inputstorycontent
+type InputStoryContent struct {
+	Type InputStoryContentType `json:"type"`
+
+	// Photo fields
+	Photo *string `json:"photo,omitempty"`
+
+	// Video fields
+	Video               *string  `json:"video,omitempty"`
+	Duration            *float64 `json:"duration,omitempty"`
+	CoverFrameTimestamp *float64 `json:"cover_frame_timestamp,omitempty"`
+	IsAnimation         *bool    `json:"is_animation,omitempty"`
+}
+
+// StoryAreaPosition describes the position of a clickable area on a story.
+// See https://core.telegram.org/bots/api#storyareaposition
+type StoryAreaPosition struct {
+	XPercentage            float64 `json:"x_percentage"`
+	YPercentage            float64 `json:"y_percentage"`
+	WidthPercentage        float64 `json:"width_percentage"`
+	HeightPercentage       float64 `json:"height_percentage"`
+	RotationAngle          float64 `json:"rotation_angle"`
+	CornerRadiusPercentage float64 `json:"corner_radius_percentage"`
+}
+
+// StoryAreaTypeType indicates the type of story area.
+type StoryAreaTypeType string
+
+const (
+	StoryAreaTypeLocationType   StoryAreaTypeType = "location"
+	StoryAreaTypeReactionType   StoryAreaTypeType = "suggested_reaction"
+	StoryAreaTypeLinkType       StoryAreaTypeType = "link"
+	StoryAreaTypeWeatherType    StoryAreaTypeType = "weather"
+	StoryAreaTypeUniqueGiftType StoryAreaTypeType = "unique_gift"
+)
+
+// StoryAreaType describes the type of a clickable area on a story.
+// Fields should be set according to the Type.
+// See https://core.telegram.org/bots/api#storyareatype
+type StoryAreaType struct {
+	Type StoryAreaTypeType `json:"type"`
+
+	// Location
+	Latitude  *float64         `json:"latitude,omitempty"`
+	Longitude *float64         `json:"longitude,omitempty"`
+	Address   *LocationAddress `json:"address,omitempty"`
+
+	// Suggested reaction
+	ReactionType *ReactionType `json:"reaction_type,omitempty"`
+	IsDark       *bool         `json:"is_dark,omitempty"`
+	IsFlipped    *bool         `json:"is_flipped,omitempty"`
+
+	// Link
+	URL *string `json:"url,omitempty"`
+
+	// Weather
+	Temperature     *float64 `json:"temperature,omitempty"`
+	Emoji           *string  `json:"emoji,omitempty"`
+	BackgroundColor *int     `json:"background_color,omitempty"`
+
+	// Unique gift
+	Name *string `json:"name,omitempty"`
+}
+
+// StoryArea represents a clickable area on a story.
+// See https://core.telegram.org/bots/api#storyarea
+type StoryArea struct {
+	Position StoryAreaPosition `json:"position"`
+	Type     StoryAreaType     `json:"type"`
+}

tgapi/chat_methods.go

@@ -0,0 +1,536 @@
+package tgapi
+
+// BanChatMemberP holds parameters for the banChatMember method.
+// See https://core.telegram.org/bots/api#banchatmember
+type BanChatMemberP struct {
+	ChatID         int64 `json:"chat_id"`
+	UserID         int64 `json:"user_id"`
+	UntilDate      int   `json:"until_date,omitempty"`
+	RevokeMessages bool  `json:"revoke_messages,omitempty"`
+}
+
+// BanChatMember bans a user in a chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#banchatmember
+func (api *API) BanChatMember(params BanChatMemberP) (bool, error) {
+	req := NewRequestWithChatID[bool]("banChatMember", params, params.ChatID)
+	return req.Do(api)
+}
+
+// UnbanChatMemberP holds parameters for the unbanChatMember method.
+// See https://core.telegram.org/bots/api#unbanchatmember
+type UnbanChatMemberP struct {
+	ChatID       int64 `json:"chat_id"`
+	UserID       int64 `json:"user_id"`
+	OnlyIfBanned bool  `json:"only_if_banned"`
+}
+
+// UnbanChatMember unbans a previously banned user in a chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#unbanchatmember
+func (api *API) UnbanChatMember(params UnbanChatMemberP) (bool, error) {
+	req := NewRequestWithChatID[bool]("unbanChatMember", params, params.ChatID)
+	return req.Do(api)
+}
+
+// RestrictChatMemberP holds parameters for the restrictChatMember method.
+// See https://core.telegram.org/bots/api#restrictchatmember
+type RestrictChatMemberP struct {
+	ChatID                        int64           `json:"chat_id"`
+	UserID                        int64           `json:"user_id"`
+	Permissions                   ChatPermissions `json:"permissions"`
+	UseIndependentChatPermissions bool            `json:"use_independent_chat_permissions,omitempty"`
+	UntilDate                     int             `json:"until_date,omitempty"`
+}
+
+// RestrictChatMember restricts a user in a chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#restrictchatmember
+func (api *API) RestrictChatMember(params RestrictChatMemberP) (bool, error) {
+	req := NewRequestWithChatID[bool]("restrictChatMember", params, params.ChatID)
+	return req.Do(api)
+}
+
+// PromoteChatMember holds parameters for the promoteChatMember method.
+// See https://core.telegram.org/bots/api#promotechatmember
+type PromoteChatMember struct {
+	ChatID      int64 `json:"chat_id"`
+	UserID      int64 `json:"user_id"`
+	IsAnonymous bool  `json:"is_anonymous,omitempty"`
+
+	CanManageChat           bool `json:"can_manage_chat,omitempty"`
+	CanDeleteMessages       bool `json:"can_delete_messages,omitempty"`
+	CanManageVideoChats     bool `json:"can_manage_video_chats,omitempty"`
+	CanRestrictMembers      bool `json:"can_restrict_members,omitempty"`
+	CanPromoteMembers       bool `json:"can_promote_members,omitempty"`
+	CanChangeInfo           bool `json:"can_change_info,omitempty"`
+	CanInviteUsers          bool `json:"can_invite_users,omitempty"`
+	CanPostStories          bool `json:"can_post_stories,omitempty"`
+	CanEditStories          bool `json:"can_edit_stories,omitempty"`
+	CanDeleteStories        bool `json:"can_delete_stories,omitempty"`
+	CanPostMessages         bool `json:"can_post_messages,omitempty"`
+	CanEditMessages         bool `json:"can_edit_messages,omitempty"`
+	CanPinMessages          bool `json:"can_pin_messages,omitempty"`
+	CanManageTopics         bool `json:"can_manage_topics,omitempty"`
+	CanManageDirectMessages bool `json:"can_manage_direct_messages,omitempty"`
+	CanManageTags           bool `json:"can_manage_tags,omitempty"`
+}
+
+// PromoteChatMember promotes or demotes a user in a chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#promotechatmember
+func (api *API) PromoteChatMember(params PromoteChatMember) (bool, error) {
+	req := NewRequestWithChatID[bool]("promoteChatMember", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetChatAdministratorCustomTitleP holds parameters for the setChatAdministratorCustomTitle method.
+// See https://core.telegram.org/bots/api#setchatadministratorcustomtitle
+type SetChatAdministratorCustomTitleP struct {
+	ChatID      int64  `json:"chat_id"`
+	UserID      int64  `json:"user_id"`
+	CustomTitle string `json:"custom_title"`
+}
+
+// SetChatAdministratorCustomTitle sets a custom title for an administrator.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setchatadministratorcustomtitle
+func (api *API) SetChatAdministratorCustomTitle(params SetChatAdministratorCustomTitleP) (bool, error) {
+	req := NewRequestWithChatID[bool]("setChatAdministratorCustomTitle", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetChatMemberTagP holds parameters for the setChatMemberTag method.
+// See https://core.telegram.org/bots/api#setchatmembertag
+type SetChatMemberTagP struct {
+	ChatID int64  `json:"chat_id"`
+	UserID int64  `json:"user_id"`
+	Tag    string `json:"tag,omitempty"`
+}
+
+// SetChatMemberTag sets a tag for a chat member.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setchatmembertag
+func (api *API) SetChatMemberTag(params SetChatMemberTagP) (bool, error) {
+	req := NewRequestWithChatID[bool]("setChatMemberTag", params, params.ChatID)
+	return req.Do(api)
+}
+
+// BanChatSenderChatP holds parameters for the banChatSenderChat method.
+// See https://core.telegram.org/bots/api#banchatsenderchat
+type BanChatSenderChatP struct {
+	ChatID       int64 `json:"chat_id"`
+	SenderChatID int64 `json:"sender_chat_id"`
+}
+
+// BanChatSenderChat bans a channel chat in a supergroup or channel.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#banchatsenderchat
+func (api *API) BanChatSenderChat(params BanChatSenderChatP) (bool, error) {
+	req := NewRequestWithChatID[bool]("banChatSenderChat", params, params.ChatID)
+	return req.Do(api)
+}
+
+// UnbanChatSenderChatP holds parameters for the unbanChatSenderChat method.
+// See https://core.telegram.org/bots/api#unbanchatsenderchat
+type UnbanChatSenderChatP struct {
+	ChatID       int64 `json:"chat_id"`
+	SenderChatID int64 `json:"sender_chat_id"`
+}
+
+// UnbanChatSenderChat unbans a previously banned channel chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#unbanchatsenderchat
+func (api *API) UnbanChatSenderChat(params UnbanChatSenderChatP) (bool, error) {
+	req := NewRequestWithChatID[bool]("unbanChatSenderChat", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetChatPermissionsP holds parameters for the setChatPermissions method.
+// See https://core.telegram.org/bots/api#setchatpermissions
+type SetChatPermissionsP struct {
+	ChatID                        int64           `json:"chat_id"`
+	Permissions                   ChatPermissions `json:"permissions"`
+	UseIndependentChatPermissions bool            `json:"use_independent_chat_permissions,omitempty"`
+}
+
+// SetChatPermissions sets default chat permissions for all members.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setchatpermissions
+func (api *API) SetChatPermissions(params SetChatPermissionsP) (bool, error) {
+	req := NewRequestWithChatID[bool]("setChatPermissions", params, params.ChatID)
+	return req.Do(api)
+}
+
+// ExportChatInviteLinkP holds parameters for the exportChatInviteLink method.
+// See https://core.telegram.org/bots/api#exportchatinvitelink
+type ExportChatInviteLinkP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// ExportChatInviteLink generates a new primary invite link for a chat.
+// Returns the new invite link as string.
+// See https://core.telegram.org/bots/api#exportchatinvitelink
+func (api *API) ExportChatInviteLink(params ExportChatInviteLinkP) (string, error) {
+	req := NewRequestWithChatID[string]("exportChatInviteLink", params, params.ChatID)
+	return req.Do(api)
+}
+
+// CreateChatInviteLinkP holds parameters for the createChatInviteLink method.
+// See https://core.telegram.org/bots/api#createchatinvitelink
+type CreateChatInviteLinkP struct {
+	ChatID             int64   `json:"chat_id"`
+	Name               *string `json:"name,omitempty"`
+	ExpireDate         int     `json:"expire_date,omitempty"`
+	MemberLimit        int     `json:"member_limit,omitempty"`
+	CreatesJoinRequest bool    `json:"creates_join_request,omitempty"`
+}
+
+// CreateChatInviteLink creates an additional invite link for a chat.
+// Returns the created invite link.
+// See https://core.telegram.org/bots/api#createchatinvitelink
+func (api *API) CreateChatInviteLink(params CreateChatInviteLinkP) (ChatInviteLink, error) {
+	req := NewRequestWithChatID[ChatInviteLink]("createChatInviteLink", params, params.ChatID)
+	return req.Do(api)
+}
+
+// EditChatInviteLinkP holds parameters for the editChatInviteLink method.
+// See https://core.telegram.org/bots/api#editchatinvitelink
+type EditChatInviteLinkP struct {
+	ChatID     int64  `json:"chat_id"`
+	InviteLink string `json:"invite_link"`
+
+	Name               string `json:"name,omitempty"`
+	ExpireDate         int    `json:"expire_date,omitempty"`
+	MemberLimit        int    `json:"member_limit,omitempty"`
+	CreatesJoinRequest bool   `json:"creates_join_request,omitempty"`
+}
+
+// EditChatInviteLink edits a non‑primary invite link.
+// Returns the edited invite link.
+// See https://core.telegram.org/bots/api#editchatinvitelink
+func (api *API) EditChatInviteLink(params EditChatInviteLinkP) (ChatInviteLink, error) {
+	req := NewRequestWithChatID[ChatInviteLink]("editChatInviteLink", params, params.ChatID)
+	return req.Do(api)
+}
+
+// CreateChatSubscriptionInviteLinkP holds parameters for the createChatSubscriptionInviteLink method.
+// See https://core.telegram.org/bots/api#createchatsubscriptioninvitelink
+type CreateChatSubscriptionInviteLinkP struct {
+	ChatID             int64  `json:"chat_id"`
+	Name               string `json:"name,omitempty"`
+	SubscriptionPeriod int    `json:"subscription_period,omitempty"`
+	SubscriptionPrice  int    `json:"subscription_price,omitempty"`
+}
+
+// CreateChatSubscriptionInviteLink creates a subscription invite link for a channel chat.
+// Returns the created invite link.
+// See https://core.telegram.org/bots/api#createchatsubscriptioninvitelink
+func (api *API) CreateChatSubscriptionInviteLink(params CreateChatSubscriptionInviteLinkP) (ChatInviteLink, error) {
+	req := NewRequestWithChatID[ChatInviteLink]("createChatSubscriptionInviteLink", params, params.ChatID)
+	return req.Do(api)
+}
+
+// EditChatSubscriptionInviteLinkP holds parameters for the editChatSubscriptionInviteLink method.
+// See https://core.telegram.org/bots/api#editchatsubscriptioninvitelink
+type EditChatSubscriptionInviteLinkP struct {
+	ChatID     int64  `json:"chat_id"`
+	InviteLink string `json:"invite_link"`
+	Name       string `json:"name,omitempty"`
+}
+
+// EditChatSubscriptionInviteLink edits a subscription invite link.
+// Returns the edited invite link.
+// See https://core.telegram.org/bots/api#editchatsubscriptioninvitelink
+func (api *API) EditChatSubscriptionInviteLink(params EditChatSubscriptionInviteLinkP) (ChatInviteLink, error) {
+	req := NewRequestWithChatID[ChatInviteLink]("editChatSubscriptionInviteLink", params, params.ChatID)
+	return req.Do(api)
+}
+
+// RevokeChatInviteLinkP holds parameters for the revokeChatInviteLink method.
+// See https://core.telegram.org/bots/api#revokechatinvitelink
+type RevokeChatInviteLinkP struct {
+	ChatID     int64  `json:"chat_id"`
+	InviteLink string `json:"invite_link"`
+}
+
+// RevokeChatInviteLink revokes an invite link.
+// Returns the revoked invite link object.
+// See https://core.telegram.org/bots/api#revokechatinvitelink
+func (api *API) RevokeChatInviteLink(params RevokeChatInviteLinkP) (ChatInviteLink, error) {
+	req := NewRequestWithChatID[ChatInviteLink]("revokeChatInviteLink", params, params.ChatID)
+	return req.Do(api)
+}
+
+// ApproveChatJoinRequestP holds parameters for the approveChatJoinRequest method.
+// See https://core.telegram.org/bots/api#approvechatjoinrequest
+type ApproveChatJoinRequestP struct {
+	ChatID int64 `json:"chat_id"`
+	UserID int64 `json:"user_id"`
+}
+
+// ApproveChatJoinRequest approves a chat join request.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#approvechatjoinrequest
+func (api *API) ApproveChatJoinRequest(params ApproveChatJoinRequestP) (bool, error) {
+	req := NewRequestWithChatID[bool]("approveChatJoinRequest", params, params.ChatID)
+	return req.Do(api)
+}
+
+// DeclineChatJoinRequestP holds parameters for the declineChatJoinRequest method.
+// See https://core.telegram.org/bots/api#declinechatjoinrequest
+type DeclineChatJoinRequestP struct {
+	ChatID int64 `json:"chat_id"`
+	UserID int64 `json:"user_id"`
+}
+
+// DeclineChatJoinRequest declines a chat join request.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#declinechatjoinrequest
+func (api *API) DeclineChatJoinRequest(params DeclineChatJoinRequestP) (bool, error) {
+	req := NewRequestWithChatID[bool]("declineChatJoinRequest", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetChatPhotoP holds parameters for the setChatPhoto method.
+// See https://core.telegram.org/bots/api#setchatphoto
+type SetChatPhotoP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// SetChatPhoto changes the chat photo.
+// photo is the file to upload as the new photo.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setchatphoto
+func (api *API) SetChatPhoto(params SetChatPhotoP, photo UploaderFile) (bool, error) {
+	uploader := NewUploader(api)
+	defer func() {
+		_ = uploader.Close()
+	}()
+	req := NewUploaderRequestWithChatID[bool]("setChatPhoto", params, params.ChatID, photo.SetType(UploaderPhotoType))
+	return req.Do(uploader)
+}
+
+// DeleteChatPhotoP holds parameters for the deleteChatPhoto method.
+// See https://core.telegram.org/bots/api#deletechatphoto
+type DeleteChatPhotoP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// DeleteChatPhoto deletes a chat photo.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#deletechatphoto
+func (api *API) DeleteChatPhoto(params DeleteChatPhotoP) (bool, error) {
+	req := NewRequestWithChatID[bool]("deleteChatPhoto", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetChatTitleP holds parameters for the setChatTitle method.
+// See https://core.telegram.org/bots/api#setchattitle
+type SetChatTitleP struct {
+	ChatID int64  `json:"chat_id"`
+	Title  string `json:"title"`
+}
+
+// SetChatTitle changes the chat title.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setchattitle
+func (api *API) SetChatTitle(params SetChatTitleP) (bool, error) {
+	req := NewRequestWithChatID[bool]("setChatTitle", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetChatDescriptionP holds parameters for the setChatDescription method.
+// See https://core.telegram.org/bots/api#setchatdescription
+type SetChatDescriptionP struct {
+	ChatID      int64  `json:"chat_id"`
+	Description string `json:"description"`
+}
+
+// SetChatDescription changes the chat description.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setchatdescription
+func (api *API) SetChatDescription(params SetChatDescriptionP) (bool, error) {
+	req := NewRequestWithChatID[bool]("setChatDescription", params, params.ChatID)
+	return req.Do(api)
+}
+
+// PinChatMessageP holds parameters for the pinChatMessage method.
+// See https://core.telegram.org/bots/api#pinchatmessage
+type PinChatMessageP struct {
+	BusinessConnectionID *string `json:"business_connection_id,omitempty"`
+	ChatID               int64   `json:"chat_id"`
+	MessageID            int     `json:"message_id"`
+	DisableNotification  bool    `json:"disable_notification,omitempty"`
+}
+
+// PinChatMessage pins a message in a chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#pinchatmessage
+func (api *API) PinChatMessage(params PinChatMessageP) (bool, error) {
+	req := NewRequestWithChatID[bool]("pinChatMessage", params, params.ChatID)
+	return req.Do(api)
+}
+
+// UnpinChatMessageP holds parameters for the unpinChatMessage method.
+// See https://core.telegram.org/bots/api#unpinchatmessage
+type UnpinChatMessageP struct {
+	BusinessConnectionID *string `json:"business_connection_id,omitempty"`
+	ChatID               int64   `json:"chat_id"`
+	MessageID            int     `json:"message_id"`
+}
+
+// UnpinChatMessage unpins a message in a chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#unpinchatmessage
+func (api *API) UnpinChatMessage(params UnpinChatMessageP) (bool, error) {
+	req := NewRequestWithChatID[bool]("unpinChatMessage", params, params.ChatID)
+	return req.Do(api)
+}
+
+// UnpinAllChatMessagesP holds parameters for the unpinAllChatMessages method.
+// See https://core.telegram.org/bots/api#unpinallchatmessages
+type UnpinAllChatMessagesP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// UnpinAllChatMessages unpins all pinned messages in a chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#unpinallchatmessages
+func (api *API) UnpinAllChatMessages(params UnpinAllChatMessagesP) (bool, error) {
+	req := NewRequestWithChatID[bool]("unpinAllChatMessages", params, params.ChatID)
+	return req.Do(api)
+}
+
+// LeaveChatP holds parameters for the leaveChat method.
+// See https://core.telegram.org/bots/api#leavechat
+type LeaveChatP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// LeaveChat makes the bot leave a chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#leavechat
+func (api *API) LeaveChat(params LeaveChatP) (bool, error) {
+	req := NewRequestWithChatID[bool]("leaveChat", params, params.ChatID) // fixed method name
+	return req.Do(api)
+}
+
+// GetChatP holds parameters for the getChat method.
+// See https://core.telegram.org/bots/api#getchat
+type GetChatP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// GetChat gets up‑to‑date information about a chat.
+// See https://core.telegram.org/bots/api#getchat
+func (api *API) GetChat(params GetChatP) (ChatFullInfo, error) {
+	req := NewRequestWithChatID[ChatFullInfo]("getChat", params, params.ChatID) // fixed method name
+	return req.Do(api)
+}
+
+// GetChatAdministratorsP holds parameters for the getChatAdministrators method.
+// See https://core.telegram.org/bots/api#getchatadministrators
+type GetChatAdministratorsP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// GetChatAdministrators returns a list of administrators in a chat.
+// See https://core.telegram.org/bots/api#getchatadministrators
+func (api *API) GetChatAdministrators(params GetChatAdministratorsP) ([]ChatMember, error) {
+	req := NewRequestWithChatID[[]ChatMember]("getChatAdministrators", params, params.ChatID)
+	return req.Do(api)
+}
+
+// GetChatMembersCountP holds parameters for the getChatMemberCount method.
+// See https://core.telegram.org/bots/api#getchatmembercount
+type GetChatMembersCountP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// GetChatMemberCount returns the number of members in a chat.
+// See https://core.telegram.org/bots/api#getchatmembercount
+func (api *API) GetChatMemberCount(params GetChatMembersCountP) (int, error) {
+	req := NewRequestWithChatID[int]("getChatMemberCount", params, params.ChatID)
+	return req.Do(api)
+}
+
+// GetChatMemberP holds parameters for the getChatMember method.
+// See https://core.telegram.org/bots/api#getchatmember
+type GetChatMemberP struct {
+	ChatID int64 `json:"chat_id"`
+	UserID int64 `json:"user_id"`
+}
+
+// GetChatMember returns information about a member of a chat.
+// See https://core.telegram.org/bots/api#getchatmember
+func (api *API) GetChatMember(params GetChatMemberP) (ChatMember, error) {
+	req := NewRequestWithChatID[ChatMember]("getChatMember", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetChatStickerSetP holds parameters for the setChatStickerSet method.
+// See https://core.telegram.org/bots/api#setchatstickerset
+type SetChatStickerSetP struct {
+	ChatID         int64  `json:"chat_id"`
+	StickerSetName string `json:"sticker_set_name"`
+}
+
+// SetChatStickerSet associates a sticker set with a supergroup.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setchatstickerset
+func (api *API) SetChatStickerSet(params SetChatStickerSetP) (bool, error) {
+	req := NewRequestWithChatID[bool]("setChatStickerSet", params, params.ChatID)
+	return req.Do(api)
+}
+
+// DeleteChatStickerSetP holds parameters for the deleteChatStickerSet method.
+// See https://core.telegram.org/bots/api#deletechatstickerset
+type DeleteChatStickerSetP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// DeleteChatStickerSet deletes a sticker set from a supergroup.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#deletechatstickerset
+func (api *API) DeleteChatStickerSet(params DeleteChatStickerSetP) (bool, error) {
+	req := NewRequestWithChatID[bool]("deleteChatStickerSet", params, params.ChatID)
+	return req.Do(api)
+}
+
+// GetUserChatBoostsP holds parameters for the getUserChatBoosts method.
+// See https://core.telegram.org/bots/api#getuserchatboosts
+type GetUserChatBoostsP struct {
+	ChatID int64 `json:"chat_id"`
+	UserID int64 `json:"user_id"`
+}
+
+// GetUserChatBoosts returns the list of boosts a user has given to a chat.
+// See https://core.telegram.org/bots/api#getuserchatboosts
+func (api *API) GetUserChatBoosts(params GetUserChatBoostsP) (UserChatBoosts, error) {
+	req := NewRequestWithChatID[UserChatBoosts]("getUserChatBoosts", params, params.ChatID)
+	return req.Do(api)
+}
+
+// GetChatGiftsP holds parameters for the getChatGifts method.
+// See https://core.telegram.org/bots/api#getchatgifts
+type GetChatGiftsP struct {
+	ChatID                      int64  `json:"chat_id"`
+	ExcludeUnsaved              bool   `json:"exclude_unsaved,omitempty"`
+	ExcludeSaved                bool   `json:"exclude_saved,omitempty"`
+	ExcludeUnlimited            bool   `json:"exclude_unlimited,omitempty"`
+	ExcludeLimitedUpgradable    bool   `json:"exclude_limited_upgradable,omitempty"`
+	ExcludeLimitedNonUpgradable bool   `json:"exclude_limited_non_upgradable,omitempty"`
+	ExcludeUnique               bool   `json:"exclude_unique,omitempty"`
+	ExcludeFromBlockchain       bool   `json:"exclude_from_blockchain,omitempty"`
+	SortByPrice                 bool   `json:"sort_by_price,omitempty"`
+	Offset                      string `json:"offset,omitempty"`
+	Limit                       int    `json:"limit,omitempty"`
+}
+
+// GetChatGifts returns gifts owned by a chat.
+// See https://core.telegram.org/bots/api#getchatgifts
+func (api *API) GetChatGifts(params GetChatGiftsP) (OwnedGifts, error) {
+	req := NewRequestWithChatID[OwnedGifts]("getChatGifts", params, params.ChatID)
+	return req.Do(api)
+}

tgapi/chat_types.go

@@ -0,0 +1,266 @@
+package tgapi
+
+// Chat represents a chat (private, group, supergroup, channel).
+// See https://core.telegram.org/bots/api#chat
+type Chat struct {
+	ID               int64   `json:"id"`
+	Type             string  `json:"type"`
+	Title            *string `json:"title,omitempty"`
+	Username         *string `json:"username,omitempty"`
+	FirstName        *string `json:"first_name,omitempty"`
+	LastName         *string `json:"last_name,omitempty"`
+	IsForum          *bool   `json:"is_forum,omitempty"`
+	IsDirectMessages *bool   `json:"is_direct_messages,omitempty"`
+}
+
+// ChatType represents the type of a chat.
+type ChatType string
+
+const (
+	ChatTypePrivate    ChatType = "private"
+	ChatTypeGroup      ChatType = "group"
+	ChatTypeSupergroup ChatType = "supergroup"
+	ChatTypeChannel    ChatType = "channel"
+)
+
+// ChatFullInfo contains full information about a chat.
+// See https://core.telegram.org/bots/api#chatfullinfo
+type ChatFullInfo struct {
+	ID               int64      `json:"id"`
+	Type             ChatType   `json:"type"`
+	Title            string     `json:"title"`
+	Username         string     `json:"username"`
+	FirstName        string     `json:"first_name"`
+	LastName         string     `json:"last_name"`
+	IsForum          bool       `json:"is_forum"`
+	IsDirectMessages bool       `json:"is_direct_messages"`
+	AccentColorID    int        `json:"accent_color_id"`
+	MaxReactionCount int        `json:"max_reaction_count"`
+	Photo            *ChatPhoto `json:"photo,omitempty"`
+	ActiveUsernames  []string   `json:"active_usernames,omitempty"`
+	Birthdate        *Birthdate `json:"birthdate,omitempty"`
+
+	BusinessIntro        *BusinessIntro        `json:"business_intro,omitempty"`
+	BusinessLocation     *BusinessLocation     `json:"business_location,omitempty"`
+	BusinessOpeningHours *BusinessOpeningHours `json:"business_opening_hours,omitempty"`
+
+	PersonalChat *Chat `json:"personal_chat,omitempty"`
+	ParentChat   *Chat `json:"parent_chat,omitempty"`
+
+	AvailableReaction []ReactionType `json:"available_reaction,omitempty"`
+
+	BackgroundCustomEmojiID        *string `json:"background_custom_emoji_id,omitempty"`
+	ProfileAccentColorID           *int    `json:"profile_accent_color_id,omitempty"`
+	ProfileBackgroundCustomEmojiID *string `json:"profile_background_custom_emoji_id,omitempty"`
+	EmojiStatusCustomEmojiID       *string `json:"emoji_status_custom_emoji_id,omitempty"`
+	EmojiStatusExpirationDate      *int    `json:"emoji_status_expiration_date,omitempty"`
+
+	Bio                                *string `json:"bio,omitempty"`
+	HasPrivateForwards                 *bool   `json:"has_private_forwards,omitempty"`
+	HasRestrictedVoiceAndVideoMessages *bool   `json:"has_restricted_voice_and_video_messages,omitempty"`
+	JoinToSendMessages                 *bool   `json:"join_to_send_messages,omitempty"`
+	JoinByRequest                      *bool   `json:"join_by_request,omitempty"`
+
+	Description       *string            `json:"description,omitempty"`
+	InviteLink        *string            `json:"invite_link,omitempty"`
+	PinnedMessage     *Message           `json:"pinned_message,omitempty"`
+	Permissions       *ChatPermissions   `json:"permissions,omitempty"`
+	AcceptedGiftTypes *AcceptedGiftTypes `json:"accepted_gift_types,omitempty"`
+
+	CanSendPaidMedia             *bool   `json:"can_send_paid_media,omitempty"`
+	SlowModeDelay                *int    `json:"slow_mode_delay,omitempty"`
+	UnrestrictedBoostCount       *int    `json:"unrestricted_boost_count,omitempty"`
+	MessageAutoDeleteTime        *int    `json:"message_auto_delete_time,omitempty"`
+	HasAggressiveAntiSpamEnabled *bool   `json:"has_aggressive_anti_spam_enabled,omitempty"`
+	HasHiddenMembers             *bool   `json:"has_hidden_members,omitempty"`
+	HasProtectedContent          *bool   `json:"has_protected_content,omitempty"`
+	HasVisibleHistory            *bool   `json:"has_visible_history,omitempty"`
+	StickerSetName               *string `json:"sticker_set_name,omitempty"`
+	CanSetStickerSet             *bool   `json:"can_set_sticker_set,omitempty"`
+	CustomEmojiStickerSetName    *string `json:"custom_emoji_sticker_set_name,omitempty"`
+	LinkedChatID                 *int64  `json:"linked_chat_id,omitempty"`
+
+	Location             *ChatLocation     `json:"location,omitempty"`
+	Rating               *UserRating       `json:"rating,omitempty"`
+	FirstProfileAudio    *Audio            `json:"first_profile_audio,omitempty"`
+	UniqueGiftColors     *UniqueGiftColors `json:"unique_gift_colors,omitempty"`
+	PaidMessageStarCount *int              `json:"paid_message_star_count,omitempty"`
+}
+
+// ChatPhoto represents a chat photo.
+// See https://core.telegram.org/bots/api#chatphoto
+type ChatPhoto struct {
+	SmallFileID       string `json:"small_file_id"`
+	SmallFileUniqueID string `json:"small_file_unique_id"`
+	BigFileID         string `json:"big_file_id"`
+	BigFileUniqueID   string `json:"big_file_unique_id"`
+}
+
+// ChatPermissions describes actions that a non‑administrator user is allowed to take in a chat.
+// See https://core.telegram.org/bots/api#chatpermissions
+type ChatPermissions struct {
+	CanSendMessages      bool `json:"can_send_messages"`
+	CanSendAudios        bool `json:"can_send_audios"`
+	CanSendDocuments     bool `json:"can_send_documents"`
+	CanSendPhotos        bool `json:"can_send_photos"`
+	CanSendVideoNotes    bool `json:"can_send_video_notes"`
+	CanSendVoiceNotes    bool `json:"can_send_voice_notes"`
+	CanSendPolls         bool `json:"can_send_polls"`
+	CanSendOtherMessages bool `json:"can_send_other_messages"`
+	CanAddWebPagePreview bool `json:"can_add_web_page_preview"`
+	CanEditTag           bool `json:"can_edit_tag"`
+	CanChangeInfo        bool `json:"can_change_info"`
+	CanInviteUsers       bool `json:"can_invite_users"`
+	CanPinMessages       bool `json:"can_pin_messages"`
+	CanManageTopics      bool `json:"can_manage_topics"`
+}
+
+// ChatLocation represents a location to which a chat is connected.
+// See https://core.telegram.org/bots/api#chatlocation
+type ChatLocation struct {
+	Location Location `json:"location"`
+	Address  string   `json:"address"`
+}
+
+// ChatInviteLink represents an invite link for a chat.
+// See https://core.telegram.org/bots/api#chatinvitelink
+type ChatInviteLink struct {
+	InviteLink        string `json:"invite_link"`
+	Creator           User   `json:"creator"`
+	CreateJoinRequest bool   `json:"creates_join_request"`
+	IsPrimary         bool   `json:"is_primary"`
+	IsRevoked         bool   `json:"is_revoked"`
+
+	Name                    *string `json:"name,omitempty"`
+	ExpireDate              *int    `json:"expire_date,omitempty"`
+	MemberLimit             *int    `json:"member_limit,omitempty"`
+	PendingJoinRequestCount *int    `json:"pending_join_request_count,omitempty"`
+	SubscriptionPeriod      *int    `json:"subscription_period,omitempty"`
+	SubscriptionPrice       *int    `json:"subscription_price,omitempty"`
+}
+
+// ChatMemberStatusType indicates the status of a chat member.
+type ChatMemberStatusType string
+
+const (
+	ChatMemberStatusOwner         ChatMemberStatusType = "owner"
+	ChatMemberStatusAdministrator ChatMemberStatusType = "administrator"
+	ChatMemberStatusMember        ChatMemberStatusType = "member"
+	ChatMemberStatusRestricted    ChatMemberStatusType = "restricted"
+	ChatMemberStatusLeft          ChatMemberStatusType = "left"
+	ChatMemberStatusBanned        ChatMemberStatusType = "kicked"
+)
+
+// ChatMember contains information about one member of a chat.
+// See https://core.telegram.org/bots/api#chatmember
+type ChatMember struct {
+	Status ChatMemberStatusType `json:"status"`
+	User   User                 `json:"user"`
+	Tag    string               `json:"tag,omitempty"`
+
+	// Owner
+	IsAnonymous *bool   `json:"is_anonymous"`
+	CustomTitle *string `json:"custom_title,omitempty"`
+
+	// Administrator
+	CanBeEdited         *bool `json:"can_be_edited,omitempty"`
+	CanManageChat       *bool `json:"can_manage_chat,omitempty"`
+	CanDeleteMessages   *bool `json:"can_delete_messages,omitempty"`
+	CanManageVideoChats *bool `json:"can_manage_video_chats,omitempty"`
+	CanRestrictMembers  *bool `json:"can_restrict_members,omitempty"`
+	CanPromoteMembers   *bool `json:"can_promote_members,omitempty"`
+	CanChangeInfo       *bool `json:"can_change_info,omitempty"`
+	CanInviteUsers      *bool `json:"can_invite_users,omitempty"`
+	CanPostStories      *bool `json:"can_post_stories,omitempty"`
+	CanEditStories      *bool `json:"can_edit_stories,omitempty"`
+	CanDeleteStories    *bool `json:"can_delete_stories,omitempty"`
+
+	CanPostMessages         *bool `json:"can_post_messages,omitempty"`
+	CanEditMessages         *bool `json:"can_edit_messages,omitempty"`
+	CanPinMessages          *bool `json:"can_pin_messages,omitempty"`
+	CanManageTopics         *bool `json:"can_manage_topics,omitempty"`
+	CanManageDirectMessages *bool `json:"can_manage_direct_messages,omitempty"`
+	CanManageTags           *bool `json:"can_manage_tags,omitempty"`
+
+	// Member
+	UntilDate *int `json:"until_date,omitempty"`
+
+	// Restricted
+	IsMember             *bool `json:"is_member,omitempty"`
+	CanSendMessages      *bool `json:"can_send_messages,omitempty"`
+	CanSendAudios        *bool `json:"can_send_audios,omitempty"`
+	CanSendDocuments     *bool `json:"can_send_documents,omitempty"`
+	CanSendVideos        *bool `json:"can_send_videos,omitempty"`
+	CanSendVideoNotes    *bool `json:"can_send_video_notes,omitempty"`
+	CanSendVoiceNotes    *bool `json:"can_send_voice_notes,omitempty"`
+	CanSendPolls         *bool `json:"can_send_polls,omitempty"`
+	CanSendOtherMessages *bool `json:"can_send_other_messages,omitempty"`
+	CanAddWebPagePreview *bool `json:"can_add_web_page_preview,omitempty"`
+	CanEditTag           *bool `json:"can_edit_tag,omitempty"`
+}
+
+// ChatBoostSource describes the source of a chat boost.
+// See https://core.telegram.org/bots/api#chatboostsource
+type ChatBoostSource struct {
+	Source string `json:"source"`
+	User   User   `json:"user"`
+
+	// Giveaway
+	GiveawayMessageID *int  `json:"giveaway_message_id,omitempty"`
+	PrizeStarCount    *int  `json:"prize_star_count,omitempty"`
+	IsUnclaimed       *bool `json:"is_unclaimed,omitempty"`
+}
+
+// ChatBoost represents a boost added to a chat.
+// See https://core.telegram.org/bots/api#chatboost
+type ChatBoost struct {
+	BoostID        int             `json:"boost_id"`
+	AddDate        int             `json:"add_date"`
+	ExpirationDate int             `json:"expiration_date"`
+	Source         ChatBoostSource `json:"source"`
+}
+
+// UserChatBoosts represents a list of boosts a user has given to a chat.
+// See https://core.telegram.org/bots/api#userchatboosts
+type UserChatBoosts struct {
+	Boosts []ChatBoost `json:"boosts"`
+}
+
+// ChatAdministratorRights represents the rights of an administrator in a chat.
+// See https://core.telegram.org/bots/api#chatadministratorrights
+type ChatAdministratorRights struct {
+	IsAnonymous         bool `json:"is_anonymous"`
+	CanManageChat       bool `json:"can_manage_chat"`
+	CanDeleteMessages   bool `json:"can_delete_messages"`
+	CanManageVideoChats bool `json:"can_manage_video_chats"`
+	CanRestrictMembers  bool `json:"can_restrict_members"`
+	CanPromoteMembers   bool `json:"can_promote_members"`
+	CanChangeInfo       bool `json:"can_change_info"`
+	CanInviteUsers      bool `json:"can_invite_users"`
+	CanPostStories      bool `json:"can_post_stories"`
+	CanEditStories      bool `json:"can_edit_stories"`
+	CanDeleteStories    bool `json:"can_delete_stories"`
+
+	CanPostMessages         *bool `json:"can_post_messages,omitempty"`
+	CanEditMessages         *bool `json:"can_edit_messages,omitempty"`
+	CanPinMessages          *bool `json:"can_pin_messages,omitempty"`
+	CanManageTopics         *bool `json:"can_manage_topics,omitempty"`
+	CanManageDirectMessages *bool `json:"can_manage_direct_messages,omitempty"`
+	CanManageTags           *bool `json:"can_manage_tags,omitempty"`
+}
+
+// ChatBoostUpdated represents a boost added to a chat or changed.
+// See https://core.telegram.org/bots/api#chatboostupdated
+type ChatBoostUpdated struct {
+	Chat  Chat      `json:"chat"`
+	Boost ChatBoost `json:"boost"`
+}
+
+// ChatBoostRemoved represents a boost removed from a chat.
+// See https://core.telegram.org/bots/api#chatboostremoved
+type ChatBoostRemoved struct {
+	Chat       Chat            `json:"chat"`
+	BoostID    string          `json:"boost_id"`
+	RemoveDate int             `json:"remove_date"`
+	Source     ChatBoostSource `json:"source"`
+}

tgapi/errors.go

@@ -0,0 +1,8 @@
+package tgapi
+
+import "errors"
+
+var ErrRateLimit = errors.New("rate limit exceeded")
+var ErrPoolUnexpected = errors.New("unexpected response from pool")
+var ErrPoolQueueFull = errors.New("worker pool queue full")
+var ErrPoolStopped = errors.New("worker pool stopped")

tgapi/forum_methods.go

@@ -0,0 +1,139 @@
+package tgapi
+
+// BaseForumTopicP contains common fields for forum topic operations that require a chat ID and a message thread ID.
+type BaseForumTopicP struct {
+	ChatID          int64 `json:"chat_id"`
+	MessageThreadID int   `json:"message_thread_id"`
+}
+
+// GetForumTopicIconStickers returns the list of custom emoji that can be used as a forum topic icon.
+// See https://core.telegram.org/bots/api#getforumtopiciconstickers
+func (api *API) GetForumTopicIconStickers() ([]Sticker, error) {
+	req := NewRequest[[]Sticker]("getForumTopicIconStickers", NoParams)
+	return req.Do(api)
+}
+
+// CreateForumTopicP holds parameters for the createForumTopic method.
+// See https://core.telegram.org/bots/api#createforumtopic
+type CreateForumTopicP struct {
+	ChatID            int64               `json:"chat_id"`
+	Name              string              `json:"name"`
+	IconColor         ForumTopicIconColor `json:"icon_color"`
+	IconCustomEmojiID string              `json:"icon_custom_emoji_id"`
+}
+
+// CreateForumTopic creates a topic in a forum supergroup.
+// Returns the created ForumTopic on success.
+// See https://core.telegram.org/bots/api#createforumtopic
+func (api *API) CreateForumTopic(params CreateForumTopicP) (ForumTopic, error) {
+	req := NewRequestWithChatID[ForumTopic]("createForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// EditForumTopicP holds parameters for the editForumTopic method.
+// See https://core.telegram.org/bots/api#editforumtopic
+type EditForumTopicP struct {
+	BaseForumTopicP
+	Name              string `json:"name"`
+	IconCustomEmojiID string `json:"icon_custom_emoji_id"`
+}
+
+// EditForumTopic edits name and icon of a forum topic.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#editforumtopic
+func (api *API) EditForumTopic(params EditForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("editForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// CloseForumTopic closes an open forum topic.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#closeforumtopic
+func (api *API) CloseForumTopic(params BaseForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("closeForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// ReopenForumTopic reopens a closed forum topic.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#reopenforumtopic
+func (api *API) ReopenForumTopic(params BaseForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("reopenForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// DeleteForumTopic deletes a forum topic.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#deleteforumtopic
+func (api *API) DeleteForumTopic(params BaseForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("deleteForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// UnpinAllForumTopicMessages clears the list of pinned messages in a forum topic.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#unpinallforumtopicmessages
+func (api *API) UnpinAllForumTopicMessages(params BaseForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("unpinAllForumTopicMessages", params, params.ChatID)
+	return req.Do(api)
+}
+
+// BaseGeneralForumTopicP contains common fields for general forum topic operations that require a chat ID.
+type BaseGeneralForumTopicP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// EditGeneralForumTopicP holds parameters for the editGeneralForumTopic method.
+// See https://core.telegram.org/bots/api#editgeneralforumtopic
+type EditGeneralForumTopicP struct {
+	ChatID int64  `json:"chat_id"`
+	Name   string `json:"name"`
+}
+
+// EditGeneralForumTopic edits the name of the 'General' topic in a forum supergroup.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#editgeneralforumtopic
+func (api *API) EditGeneralForumTopic(params EditGeneralForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("editGeneralForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// CloseGeneralForumTopic closes the 'General' topic in a forum supergroup.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#closegeneralforumtopic
+func (api *API) CloseGeneralForumTopic(params BaseGeneralForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("closeGeneralForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// ReopenGeneralForumTopic reopens the 'General' topic in a forum supergroup.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#reopengeneralforumtopic
+func (api *API) ReopenGeneralForumTopic(params BaseGeneralForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("reopenGeneralForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// HideGeneralForumTopic hides the 'General' topic in a forum supergroup.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#hidegeneralforumtopic
+func (api *API) HideGeneralForumTopic(params BaseGeneralForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("hideGeneralForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// UnhideGeneralForumTopic unhides the 'General' topic in a forum supergroup.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#unhidegeneralforumtopic
+func (api *API) UnhideGeneralForumTopic(params BaseGeneralForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("unhideGeneralForumTopic", params, params.ChatID)
+	return req.Do(api)
+}
+
+// UnpinAllGeneralForumTopicMessages clears the list of pinned messages in the 'General' topic.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#unpinallgeneralforumtopicmessages
+func (api *API) UnpinAllGeneralForumTopicMessages(params BaseGeneralForumTopicP) (bool, error) {
+	req := NewRequestWithChatID[bool]("unpinAllGeneralForumTopicMessages", params, params.ChatID)
+	return req.Do(api)
+}

tgapi/forum_types.go

@@ -0,0 +1,21 @@
+package tgapi
+
+// ForumTopic represents a forum topic.
+// See https://core.telegram.org/bots/api#forumtopic
+type ForumTopic struct {
+	MessageThreadID   int    `json:"message_thread_id"`
+	Name              string `json:"name"`
+	IconColor         int    `json:"icon_color"`
+	IconCustomEmojiID string `json:"icon_custom_emoji_id,omitempty"`
+	IsNameImplicit    bool   `json:"is_name_implicit,omitempty"`
+}
+
+// ForumTopicIconColor represents the color of a forum topic icon.
+// The value is an integer representing the color in RGB format.
+// See https://core.telegram.org/bots/api#forumtopiciconcolor
+type ForumTopicIconColor int
+
+const (
+	// ForumTopicIconColorBlue is the blue color for forum topic icons (value 7322096).
+	ForumTopicIconColorBlue ForumTopicIconColor = 7322096
+)

tgapi/games_methods.go

@@ -0,0 +1,69 @@
+package tgapi
+
+// SendGameP holds parameters for the sendGame method.
+// See https://core.telegram.org/bots/api#sendgame
+type SendGameP struct {
+	BusinessConnectionID string `json:"business_connection_id,omitempty"`
+	ChatID               int64  `json:"chat_id"`
+	MessageThreadID      int    `json:"message_thread_id,omitempty"`
+
+	GameShortName string `json:"game_short_name"`
+
+	DisableNotification bool                  `json:"disable_notification,omitempty"`
+	ProtectContent      bool                  `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool                  `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string                `json:"message_effect_id,omitempty"`
+	ReplyParameters     *ReplyParameters      `json:"reply_parameters,omitempty"`
+	ReplyMarkup         *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+// SendGame sends a game message.
+// See https://core.telegram.org/bots/api#sendgame
+func (api *API) SendGame(params SendGameP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendGame", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetGameScoreP holds parameters for the setGameScore method.
+// See https://core.telegram.org/bots/api#setgamescore
+type SetGameScoreP struct {
+	UserID             int64  `json:"user_id"`
+	Score              int    `json:"score"`
+	Force              bool   `json:"force,omitempty"`
+	DisableEditMessage bool   `json:"disable_edit_message,omitempty"`
+	ChatID             int64  `json:"chat_id,omitempty"`
+	MessageID          int    `json:"message_id,omitempty"`
+	InlineMessageID    string `json:"inline_message_id,omitempty"`
+}
+
+// SetGameScore sets a user's score in a game message.
+// If inline_message_id is provided, returns a boolean success flag.
+// Otherwise returns the edited Message.
+// See https://core.telegram.org/bots/api#setgamescore
+func (api *API) SetGameScore(params SetGameScoreP) (Message, bool, error) {
+	var zero Message
+	if params.InlineMessageID != "" {
+		req := NewRequestWithChatID[bool]("setGameScore", params, params.ChatID)
+		res, err := req.Do(api)
+		return zero, res, err
+	}
+	req := NewRequestWithChatID[Message]("setGameScore", params, params.ChatID)
+	res, err := req.Do(api)
+	return res, false, err
+}
+
+// GetGameHighScoresP holds parameters for the getGameHighScores method.
+// See https://core.telegram.org/bots/api#getgamehighscores
+type GetGameHighScoresP struct {
+	UserID          int64  `json:"user_id"`
+	ChatID          int64  `json:"chat_id,omitempty"`
+	MessageID       int    `json:"message_id,omitempty"`
+	InlineMessageID string `json:"inline_message_id,omitempty"`
+}
+
+// GetGameHighScores returns game high score data for a user.
+// See https://core.telegram.org/bots/api#getgamehighscores
+func (api *API) GetGameHighScores(params GetGameHighScoresP) ([]GameHighScore, error) {
+	req := NewRequestWithChatID[[]GameHighScore]("getGameHighScores", params, params.ChatID)
+	return req.Do(api)
+}

tgapi/games_types.go

@@ -0,0 +1,9 @@
+package tgapi
+
+// GameHighScore represents one row in a game high score table.
+// See https://core.telegram.org/bots/api#gamehighscore
+type GameHighScore struct {
+	Position int  `json:"position"`
+	User     User `json:"user"`
+	Score    int  `json:"score"`
+}

tgapi/inline_methods.go

@@ -0,0 +1,52 @@
+package tgapi
+
+// AnswerInlineQueryP holds parameters for the answerInlineQuery method.
+// See https://core.telegram.org/bots/api#answerinlinequery
+type AnswerInlineQueryP struct {
+	InlineQueryID string                    `json:"inline_query_id"`
+	Results       []InlineQueryResult       `json:"results"`
+	CacheTime     int                       `json:"cache_time,omitempty"`
+	IsPersonal    bool                      `json:"is_personal,omitempty"`
+	NextOffset    string                    `json:"next_offset,omitempty"`
+	Button        *InlineQueryResultsButton `json:"button,omitempty"`
+}
+
+// AnswerInlineQuery sends answers to an inline query.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#answerinlinequery
+func (api *API) AnswerInlineQuery(params AnswerInlineQueryP) (bool, error) {
+	req := NewRequest[bool]("answerInlineQuery", params)
+	return req.Do(api)
+}
+
+// AnswerWebAppQueryP holds parameters for the answerWebAppQuery method.
+// See https://core.telegram.org/bots/api#answerwebappquery
+type AnswerWebAppQueryP struct {
+	WebAppQueryID string            `json:"web_app_query_id"`
+	Result        InlineQueryResult `json:"result"`
+}
+
+// AnswerWebAppQuery sets the result of a Web App interaction.
+// See https://core.telegram.org/bots/api#answerwebappquery
+func (api *API) AnswerWebAppQuery(params AnswerWebAppQueryP) (SentWebAppMessage, error) {
+	req := NewRequest[SentWebAppMessage]("answerWebAppQuery", params)
+	return req.Do(api)
+}
+
+// SavePreparedInlineMessageP holds parameters for the savePreparedInlineMessage method.
+// See https://core.telegram.org/bots/api#savepreparedinlinemessage
+type SavePreparedInlineMessageP struct {
+	UserID            int64             `json:"user_id"`
+	Result            InlineQueryResult `json:"result"`
+	AllowUserChats    bool              `json:"allow_user_chats,omitempty"`
+	AllowBotChats     bool              `json:"allow_bot_chats,omitempty"`
+	AllowGroupChats   bool              `json:"allow_group_chats,omitempty"`
+	AllowChannelChats bool              `json:"allow_channel_chats,omitempty"`
+}
+
+// SavePreparedInlineMessage stores a prepared message for Mini App users.
+// See https://core.telegram.org/bots/api#savepreparedinlinemessage
+func (api *API) SavePreparedInlineMessage(params SavePreparedInlineMessageP) (PreparedInlineMessage, error) {
+	req := NewRequest[PreparedInlineMessage]("savePreparedInlineMessage", params)
+	return req.Do(api)
+}

tgapi/inline_types.go

@@ -0,0 +1,26 @@
+package tgapi
+
+// InlineQueryResult is a JSON-serializable inline query result object.
+// See https://core.telegram.org/bots/api#inlinequeryresult
+type InlineQueryResult map[string]any
+
+// InlineQueryResultsButton represents a button shown above inline query results.
+// See https://core.telegram.org/bots/api#inlinequeryresultsbutton
+type InlineQueryResultsButton struct {
+	Text           string      `json:"text"`
+	WebApp         *WebAppInfo `json:"web_app,omitempty"`
+	StartParameter string      `json:"start_parameter,omitempty"`
+}
+
+// SentWebAppMessage describes an inline message sent by a Web App on behalf of a user.
+// See https://core.telegram.org/bots/api#sentwebappmessage
+type SentWebAppMessage struct {
+	InlineMessageID string `json:"inline_message_id,omitempty"`
+}
+
+// PreparedInlineMessage describes a prepared inline message.
+// See https://core.telegram.org/bots/api#preparedinlinemessage
+type PreparedInlineMessage struct {
+	ID             string `json:"id"`
+	ExpirationDate int    `json:"expiration_date"`
+}

tgapi/messages_methods.go

@@ -0,0 +1,650 @@
+package tgapi
+
+// SendMessageP holds parameters for the sendMessage method.
+// See https://core.telegram.org/bots/api#sendmessage
+type SendMessageP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int64  `json:"direct_messages_topic_id,omitempty"`
+
+	Text                 string              `json:"text"`
+	ParseMode            ParseMode           `json:"parse_mode,omitempty"`
+	Entities             []MessageEntity     `json:"entities,omitempty"`
+	LinkPreviewOptions   *LinkPreviewOptions `json:"link_preview_options,omitempty"`
+	DisableNotifications bool                `json:"disable_notification,omitempty"`
+	ProtectContent       bool                `json:"protect_content,omitempty"`
+	AllowPaidBroadcast   bool                `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID      string              `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendMessage sends a text message.
+// See https://core.telegram.org/bots/api#sendmessage
+func (api *API) SendMessage(params SendMessageP) (Message, error) {
+	req := NewRequestWithChatID[Message, SendMessageP]("sendMessage", params, params.ChatID)
+	return req.Do(api)
+}
+
+// ForwardMessageP holds parameters for the forwardMessage method.
+// See https://core.telegram.org/bots/api#forwardmessage
+type ForwardMessageP struct {
+	ChatID                int64 `json:"chat_id"`
+	MessageThreadID       int   `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
+
+	MessageID           int   `json:"message_id,omitempty"`
+	FromChatID          int64 `json:"from_chat_id,omitempty"`
+	VideoStartTimestamp int   `json:"video_start_timestamp,omitempty"`
+	DisableNotification bool  `json:"disable_notification,omitempty"`
+	ProtectContent      bool  `json:"protect_content,omitempty"`
+
+	MessageEffectID         string                   `json:"message_effect_id,omitempty"`
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+}
+
+// ForwardMessage forwards a message.
+// See https://core.telegram.org/bots/api#forwardmessage
+func (api *API) ForwardMessage(params ForwardMessageP) (Message, error) {
+	req := NewRequestWithChatID[Message]("forwardMessage", params, params.ChatID)
+	return req.Do(api)
+}
+
+// ForwardMessagesP holds parameters for the forwardMessages method.
+// See https://core.telegram.org/bots/api#forwardmessages
+type ForwardMessagesP struct {
+	ChatID                int64 `json:"chat_id"`
+	MessageThreadID       int   `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
+
+	FromChatID          int64 `json:"from_chat_id,omitempty"`
+	MessageIDs          []int `json:"message_ids,omitempty"`
+	DisableNotification bool  `json:"disable_notification,omitempty"`
+	ProtectContent      bool  `json:"protect_content,omitempty"`
+}
+
+// ForwardMessages forwards multiple messages.
+// Returns an array of message IDs of the sent messages.
+// See https://core.telegram.org/bots/api#forwardmessages
+func (api *API) ForwardMessages(params ForwardMessagesP) ([]MessageID, error) {
+	req := NewRequestWithChatID[[]MessageID]("forwardMessages", params, params.ChatID)
+	return req.Do(api)
+}
+
+// CopyMessageP holds parameters for the copyMessage method.
+// See https://core.telegram.org/bots/api#copymessage
+type CopyMessageP struct {
+	ChatID                int64 `json:"chat_id"`
+	MessageThreadID       int   `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
+
+	FromChatID          int64     `json:"from_chat_id"`
+	MessageID           int       `json:"message_id"`
+	VideoStartTimestamp int       `json:"video_start_timestamp,omitempty"`
+	Caption             string    `json:"caption,omitempty"`
+	ParseMode           ParseMode `json:"parse_mode,omitempty"`
+
+	CaptionEntities       []MessageEntity `json:"caption_entities,omitempty"`
+	ShowCaptionAboveMedia bool            `json:"show_caption_above_media,omitempty"`
+	DisableNotification   bool            `json:"disable_notification,omitempty"`
+	ProtectContent        bool            `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool            `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string          `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// CopyMessage copies a message.
+// Returns the MessageID of the sent copy.
+// See https://core.telegram.org/bots/api#copymessage
+func (api *API) CopyMessage(params CopyMessageP) (int, error) {
+	msgID, err := NewRequestWithChatID[MessageID]("copyMessage", params, params.ChatID).Do(api)
+	if err != nil {
+		return 0, err
+	}
+	return msgID.MessageID, nil
+}
+
+// CopyMessagesP holds parameters for the copyMessages method.
+// See https://core.telegram.org/bots/api#copymessages
+type CopyMessagesP struct {
+	ChatID                int64 `json:"chat_id"`
+	MessageThreadID       int   `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int   `json:"direct_messages_topic_id,omitempty"`
+
+	FromChatID          int64 `json:"from_chat_id,omitempty"`
+	MessageIDs          []int `json:"message_ids,omitempty"`
+	DisableNotification bool  `json:"disable_notification,omitempty"`
+	ProtectContent      bool  `json:"protect_content,omitempty"`
+	RemoveCaption       bool  `json:"remove_caption,omitempty"`
+}
+
+// CopyMessages copies multiple messages.
+// Returns an array of message IDs of the sent copies.
+// See https://core.telegram.org/bots/api#copymessages
+func (api *API) CopyMessages(params CopyMessagesP) ([]MessageID, error) {
+	req := NewRequestWithChatID[[]MessageID]("copyMessages", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendLocationP holds parameters for the sendLocation method.
+// See https://core.telegram.org/bots/api#sendlocation
+type SendLocationP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Latitude             float64 `json:"latitude"`
+	Longitude            float64 `json:"longitude"`
+	HorizontalAccuracy   float64 `json:"horizontal_accuracy,omitempty"`
+	LivePeriod           int     `json:"live_period,omitempty"`
+	Heading              int     `json:"heading,omitempty"`
+	ProximityAlertRadius int     `json:"proximity_alert_radius,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendLocation sends a point on the map.
+// See https://core.telegram.org/bots/api#sendlocation
+func (api *API) SendLocation(params SendLocationP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendLocation", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendVenueP holds parameters for the sendVenue method.
+// See https://core.telegram.org/bots/api#sendvenue
+type SendVenueP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Latitude        float64 `json:"latitude"`
+	Longitude       float64 `json:"longitude"`
+	Title           string  `json:"title"`
+	Address         string  `json:"address"`
+	FoursquareID    string  `json:"foursquare_id,omitempty"`
+	FoursquareType  string  `json:"foursquare_type,omitempty"`
+	GooglePlaceID   string  `json:"google_place_id,omitempty"`
+	GooglePlaceType string  `json:"google_place_type,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendVenue sends information about a venue.
+// See https://core.telegram.org/bots/api#sendvenue
+func (api *API) SendVenue(params SendVenueP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendVenue", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendContactP holds parameters for the sendContact method.
+// See https://core.telegram.org/bots/api#sendcontact
+type SendContactP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	PhoneNumber string `json:"phone_number"`
+	FirstName   string `json:"first_name"`
+	LastName    string `json:"last_name,omitempty"`
+	Vcard       string `json:"vcard"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendContact sends a phone contact.
+// See https://core.telegram.org/bots/api#sendcontact
+func (api *API) SendContact(params SendContactP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendContact", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendPollP holds parameters for the sendPoll method.
+// See https://core.telegram.org/bots/api#sendpoll
+type SendPollP struct {
+	BusinessConnectionID string `json:"business_connection_id,omitempty"`
+	ChatID               int64  `json:"chat_id"`
+	MessageThreadID      int    `json:"message_thread_id,omitempty"`
+
+	Question              string            `json:"question"`
+	QuestionParseMode     ParseMode         `json:"question_parse_mode,omitempty"`
+	QuestionEntities      []MessageEntity   `json:"question_entities,omitempty"`
+	Options               []InputPollOption `json:"options"`
+	IsAnonymous           bool              `json:"is_anonymous,omitempty"`
+	Type                  PollType          `json:"type"`
+	AllowsMultipleAnswers bool              `json:"allows_multiple_answers,omitempty"`
+	CorrectOptionID       int               `json:"correct_option_id,omitempty"`
+	Explanation           string            `json:"explanation,omitempty"`
+	ExplanationParseMode  ParseMode         `json:"explanation_parse_mode,omitempty"`
+	ExplanationEntities   []MessageEntity   `json:"explanation_entities,omitempty"`
+	OpenPeriod            int               `json:"open_period,omitempty"`
+	CloseDate             int               `json:"close_date"`
+	IsClosed              bool              `json:"is_closed,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	ReplyParameters *ReplyParameters `json:"reply_parameters,omitempty"`
+	ReplyMarkup     *ReplyMarkup     `json:"reply_markup,omitempty"`
+}
+
+// SendPoll sends a native poll.
+// See https://core.telegram.org/bots/api#sendpoll
+func (api *API) SendPoll(params SendPollP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendPoll", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendChecklistP holds parameters for the sendChecklist method.
+// See https://core.telegram.org/bots/api#sendchecklist
+type SendChecklistP struct {
+	BusinessConnectionID string         `json:"business_connection_id"`
+	ChatID               int64          `json:"chat_id"`
+	Checklist            InputChecklist `json:"checklist"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	ReplyParameters *ReplyParameters `json:"reply_parameters,omitempty"`
+	ReplyMarkup     *ReplyMarkup     `json:"reply_markup,omitempty"`
+}
+
+// SendChecklist sends a checklist.
+// See https://core.telegram.org/bots/api#sendchecklist
+func (api *API) SendChecklist(params SendChecklistP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendChecklist", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendDiceP holds parameters for the sendDice method.
+// See https://core.telegram.org/bots/api#senddice
+type SendDiceP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Emoji string `json:"emoji,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendDice sends a dice, which will have a random value.
+// See https://core.telegram.org/bots/api#senddice
+func (api *API) SendDice(params SendDiceP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendDice", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendMessageDraftP holds parameters for the sendMessageDraft method.
+// See https://core.telegram.org/bots/api#sendmessagedraft
+type SendMessageDraftP struct {
+	ChatID          int64           `json:"chat_id"`
+	MessageThreadID int             `json:"message_thread_id,omitempty"`
+	DraftID         uint64          `json:"draft_id"`
+	Text            string          `json:"text"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	Entities        []MessageEntity `json:"entities,omitempty"`
+}
+
+// SendMessageDraft sends or updates a draft message in the target chat.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#sendmessagedraft
+func (api *API) SendMessageDraft(params SendMessageDraftP) (bool, error) {
+	req := NewRequestWithChatID[bool]("sendMessageDraft", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SendChatActionP holds parameters for the sendChatAction method.
+// See https://core.telegram.org/bots/api#sendchataction
+type SendChatActionP struct {
+	BusinessConnectionID string         `json:"business_connection_id,omitempty"`
+	ChatID               int64          `json:"chat_id"`
+	MessageThreadID      int            `json:"message_thread_id,omitempty"`
+	Action               ChatActionType `json:"action"`
+}
+
+// SendChatAction sends a chat action (typing, uploading photo, etc.).
+// Returns True on success.
+// See https://core.telegram.org/bots/api#sendchataction
+func (api *API) SendChatAction(params SendChatActionP) (bool, error) {
+	req := NewRequestWithChatID[bool]("sendChatAction", params, params.ChatID)
+	return req.Do(api)
+}
+
+// SetMessageReactionP holds parameters for the setMessageReaction method.
+// See https://core.telegram.org/bots/api#setmessagereaction
+type SetMessageReactionP struct {
+	ChatID    int64          `json:"chat_id"`
+	MessageId int            `json:"message_id"`
+	Reaction  []ReactionType `json:"reaction"`
+	IsBig     bool           `json:"is_big,omitempty"`
+}
+
+// SetMessageReaction changes the chosen reaction on a message.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setmessagereaction
+func (api *API) SetMessageReaction(params SetMessageReactionP) (bool, error) {
+	req := NewRequestWithChatID[bool]("setMessageReaction", params, params.ChatID)
+	return req.Do(api)
+}
+
+// EditMessageTextP holds parameters for the editMessageText method.
+// See https://core.telegram.org/bots/api#editmessagetext
+type EditMessageTextP struct {
+	BusinessConnectionID string       `json:"business_connection_id,omitempty"`
+	ChatID               int64        `json:"chat_id,omitempty"`
+	MessageID            int          `json:"message_id,omitempty"`
+	InlineMessageID      string       `json:"inline_message_id,omitempty"`
+	Text                 string       `json:"text"`
+	ParseMode            ParseMode    `json:"parse_mode,omitempty"`
+	ReplyMarkup          *ReplyMarkup `json:"reply_markup,omitempty"`
+}
+
+// EditMessageText edits text messages.
+// If inline_message_id is provided, returns a boolean success flag;
+// otherwise returns the edited Message.
+// See https://core.telegram.org/bots/api#editmessagetext
+func (api *API) EditMessageText(params EditMessageTextP) (Message, bool, error) {
+	var zero Message
+	if params.InlineMessageID != "" {
+		req := NewRequestWithChatID[bool]("editMessageText", params, params.ChatID)
+		res, err := req.Do(api)
+		return zero, res, err
+	}
+	req := NewRequestWithChatID[Message]("editMessageText", params, params.ChatID)
+	res, err := req.Do(api)
+	return res, false, err
+}
+
+// EditMessageCaptionP holds parameters for the editMessageCaption method.
+// See https://core.telegram.org/bots/api#editmessagecaption
+type EditMessageCaptionP struct {
+	BusinessConnectionID string       `json:"business_connection_id,omitempty"`
+	ChatID               int64        `json:"chat_id,omitempty"`
+	MessageID            int          `json:"message_id,omitempty"`
+	InlineMessageID      string       `json:"inline_message_id,omitempty"`
+	Caption              string       `json:"caption"`
+	ParseMode            ParseMode    `json:"parse_mode,omitempty"`
+	ReplyMarkup          *ReplyMarkup `json:"reply_markup,omitempty"`
+}
+
+// EditMessageCaption edits captions of messages.
+// If inline_message_id is provided, returns a boolean success flag;
+// otherwise returns the edited Message.
+// See https://core.telegram.org/bots/api#editmessagecaption
+func (api *API) EditMessageCaption(params EditMessageCaptionP) (Message, bool, error) {
+	var zero Message
+	if params.InlineMessageID != "" {
+		req := NewRequestWithChatID[bool]("editMessageCaption", params, params.ChatID)
+		res, err := req.Do(api)
+		return zero, res, err
+	}
+	req := NewRequestWithChatID[Message]("editMessageCaption", params, params.ChatID)
+	res, err := req.Do(api)
+	return res, false, err
+}
+
+// EditMessageMediaP holds parameters for the editMessageMedia method.
+// See https://core.telegram.org/bots/api#editmessagemedia
+type EditMessageMediaP struct {
+	BusinessConnectionID string                `json:"business_connection_id,omitempty"`
+	ChatID               int64                 `json:"chat_id,omitempty"`
+	MessageID            int                   `json:"message_id,omitempty"`
+	InlineMessageID      string                `json:"inline_message_id,omitempty"`
+	Media                InputMedia            `json:"media"`
+	ReplyMarkup          *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+// EditMessageMedia edits media messages.
+// If inline_message_id is provided, returns a boolean success flag;
+// otherwise returns the edited Message.
+// See https://core.telegram.org/bots/api#editmessagemedia
+func (api *API) EditMessageMedia(params EditMessageMediaP) (Message, bool, error) {
+	var zero Message
+	if params.InlineMessageID != "" {
+		req := NewRequestWithChatID[bool]("editMessageMedia", params, params.ChatID)
+		res, err := req.Do(api)
+		return zero, res, err
+	}
+	req := NewRequestWithChatID[Message]("editMessageMedia", params, params.ChatID)
+	res, err := req.Do(api)
+	return res, false, err
+}
+
+// EditMessageLiveLocationP holds parameters for the editMessageLiveLocation method.
+// See https://core.telegram.org/bots/api#editmessagelivelocation
+type EditMessageLiveLocationP struct {
+	BusinessConnectionID string `json:"business_connection_id,omitempty"`
+	ChatID               int64  `json:"chat_id,omitempty"`
+	MessageID            int    `json:"message_id,omitempty"`
+	InlineMessageID      string `json:"inline_message_id,omitempty"`
+
+	Latitude             float64               `json:"latitude"`
+	Longitude            float64               `json:"longitude"`
+	LivePeriod           int                   `json:"live_period,omitempty"`
+	HorizontalAccuracy   float64               `json:"horizontal_accuracy,omitempty"`
+	Heading              int                   `json:"heading,omitempty"`
+	ProximityAlertRadius int                   `json:"proximity_alert_radius,omitempty"`
+	ReplyMarkup          *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+// EditMessageLiveLocation edits live location messages.
+// If inline_message_id is provided, returns a boolean success flag;
+// otherwise returns the edited Message.
+// See https://core.telegram.org/bots/api#editmessagelivelocation
+func (api *API) EditMessageLiveLocation(params EditMessageLiveLocationP) (Message, bool, error) {
+	var zero Message
+	if params.InlineMessageID != "" {
+		req := NewRequestWithChatID[bool]("editMessageLiveLocation", params, params.ChatID)
+		res, err := req.Do(api)
+		return zero, res, err
+	}
+	req := NewRequestWithChatID[Message]("editMessageLiveLocation", params, params.ChatID)
+	res, err := req.Do(api)
+	return res, false, err
+}
+
+// StopMessageLiveLocationP holds parameters for the stopMessageLiveLocation method.
+// See https://core.telegram.org/bots/api#stopmessagelivelocation
+type StopMessageLiveLocationP struct {
+	BusinessConnectionID string                `json:"business_connection_id,omitempty"`
+	ChatID               int64                 `json:"chat_id,omitempty"`
+	MessageID            int                   `json:"message_id,omitempty"`
+	InlineMessageID      string                `json:"inline_message_id,omitempty"`
+	ReplyMarkup          *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+// StopMessageLiveLocation stops a live location message.
+// If inline_message_id is provided, returns a boolean success flag;
+// otherwise returns the edited Message.
+// See https://core.telegram.org/bots/api#stopmessagelivelocation
+func (api *API) StopMessageLiveLocation(params StopMessageLiveLocationP) (Message, bool, error) {
+	var zero Message
+	if params.InlineMessageID != "" {
+		req := NewRequestWithChatID[bool]("stopMessageLiveLocation", params, params.ChatID)
+		res, err := req.Do(api)
+		return zero, res, err
+	}
+	req := NewRequestWithChatID[Message]("stopMessageLiveLocation", params, params.ChatID)
+	res, err := req.Do(api)
+	return res, false, err
+}
+
+// EditMessageChecklistP holds parameters for the editMessageChecklist method.
+type EditMessageChecklistP struct {
+	BusinessConnectionID string                `json:"business_connection_id"`
+	ChatID               int64                 `json:"chat_id"`
+	MessageID            int                   `json:"message_id"`
+	Checklist            InputChecklist        `json:"checklist"`
+	ReplyMarkup          *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+// EditMessageChecklist edits a checklist message.
+// See https://core.telegram.org/bots/api#editmessagechecklist
+func (api *API) EditMessageChecklist(params EditMessageChecklistP) (Message, error) {
+	req := NewRequestWithChatID[Message]("editMessageChecklist", params, params.ChatID)
+	return req.Do(api)
+}
+
+// EditMessageReplyMarkupP holds parameters for the editMessageReplyMarkup method.
+// See https://core.telegram.org/bots/api#editmessagereplymarkup
+type EditMessageReplyMarkupP struct {
+	BusinessConnectionID string                `json:"business_connection_id,omitempty"`
+	ChatID               int64                 `json:"chat_id,omitempty"`
+	MessageID            int                   `json:"message_id,omitempty"`
+	InlineMessageID      string                `json:"inline_message_id,omitempty"`
+	ReplyMarkup          *InlineKeyboardMarkup `json:"reply_markup,omitempty"`
+}
+
+// EditMessageReplyMarkup edits only the reply markup of messages.
+// If inline_message_id is provided, returns a boolean success flag;
+// otherwise returns the edited Message.
+// See https://core.telegram.org/bots/api#editmessagereplymarkup
+func (api *API) EditMessageReplyMarkup(params EditMessageReplyMarkupP) (Message, bool, error) {
+	var zero Message
+	if params.InlineMessageID != "" {
+		req := NewRequestWithChatID[bool]("editMessageReplyMarkup", params, params.ChatID)
+		res, err := req.Do(api)
+		return zero, res, err
+	}
+	req := NewRequestWithChatID[Message]("editMessageReplyMarkup", params, params.ChatID)
+	res, err := req.Do(api)
+	return res, false, err
+}
+
+// StopPollP holds parameters for the stopPoll method.
+// See https://core.telegram.org/bots/api#stoppoll
+type StopPollP struct {
+	BusinessConnectionID string `json:"business_connection_id,omitempty"`
+	ChatID               int64  `json:"chat_id"`
+	MessageID            int    `json:"message_id"`
+	InlineMessageID      string `json:"inline_message_id,omitempty"`
+}
+
+// StopPoll stops a poll that was sent by the bot.
+// Returns the stopped Poll.
+// See https://core.telegram.org/bots/api#stoppoll
+func (api *API) StopPoll(params StopPollP) (Poll, error) {
+	req := NewRequestWithChatID[Poll]("stopPoll", params, params.ChatID)
+	return req.Do(api)
+}
+
+// ApproveSuggestedPostP holds parameters for the approveSuggestedPost method.
+// See https://core.telegram.org/bots/api#approvesuggestedpost
+type ApproveSuggestedPostP struct {
+	ChatID    int64 `json:"chat_id"`
+	MessageID int   `json:"message_id"`
+	SendDate  int   `json:"send_date,omitempty"`
+}
+
+// ApproveSuggestedPost approves a suggested channel post.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#approvesuggestedpost
+func (api *API) ApproveSuggestedPost(params ApproveSuggestedPostP) (bool, error) {
+	req := NewRequestWithChatID[bool]("approveSuggestedPost", params, params.ChatID)
+	return req.Do(api)
+}
+
+// DeclineSuggestedPostP holds parameters for the declineSuggestedPost method.
+// See https://core.telegram.org/bots/api#declinesuggestedpost
+type DeclineSuggestedPostP struct {
+	ChatID    int64  `json:"chat_id"`
+	MessageID int    `json:"message_id"`
+	Comment   string `json:"comment,omitempty"`
+}
+
+// DeclineSuggestedPost declines a suggested channel post.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#declinesuggestedpost
+func (api *API) DeclineSuggestedPost(params DeclineSuggestedPostP) (bool, error) {
+	req := NewRequestWithChatID[bool]("declineSuggestedPost", params, params.ChatID)
+	return req.Do(api)
+}
+
+// DeleteMessageP holds parameters for the deleteMessage method.
+// See https://core.telegram.org/bots/api#deletemessage
+type DeleteMessageP struct {
+	ChatID    int64 `json:"chat_id"`
+	MessageID int   `json:"message_id"`
+}
+
+// DeleteMessage deletes a message.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#deletemessage
+func (api *API) DeleteMessage(params DeleteMessageP) (bool, error) {
+	req := NewRequestWithChatID[bool]("deleteMessage", params, params.ChatID)
+	return req.Do(api)
+}
+
+// DeleteMessagesP holds parameters for the deleteMessages method.
+// See https://core.telegram.org/bots/api#deletemessages
+type DeleteMessagesP struct {
+	ChatID     int64 `json:"chat_id"`
+	MessageIDs []int `json:"message_ids"`
+}
+
+// DeleteMessages deletes multiple messages at once.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#deletemessages
+func (api *API) DeleteMessages(params DeleteMessagesP) (bool, error) {
+	req := NewRequestWithChatID[bool]("deleteMessages", params, params.ChatID)
+	return req.Do(api)
+}
+
+// AnswerCallbackQueryP holds parameters for the answerCallbackQuery method.
+// See https://core.telegram.org/bots/api#answercallbackquery
+type AnswerCallbackQueryP struct {
+	CallbackQueryID string `json:"callback_query_id"`
+	Text            string `json:"text,omitempty"`
+	ShowAlert       bool   `json:"show_alert,omitempty"`
+	URL             string `json:"url,omitempty"`
+	CacheTime       int    `json:"cache_time,omitempty"`
+}
+
+// AnswerCallbackQuery sends answers to callback queries sent from inline keyboards.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#answercallbackquery
+func (api *API) AnswerCallbackQuery(params AnswerCallbackQueryP) (bool, error) {
+	req := NewRequest[bool]("answerCallbackQuery", params)
+	return req.Do(api)
+}

tgapi/messages_types.go

@@ -0,0 +1,360 @@
+package tgapi
+
+import "git.nix13.pw/scuroneko/extypes"
+
+// MessageID represents a message identifier wrapper returned by some API methods.
+type MessageID struct {
+	MessageID int `json:"message_id"`
+}
+
+// MessageReplyMarkup represents an inline keyboard markup for a message.
+// It is used in the Message type.
+type MessageReplyMarkup struct {
+	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard"`
+}
+
+// DirectMessageTopic represents a forum topic in a direct message.
+type DirectMessageTopic struct {
+	TopicID int64 `json:"topic_id"`
+	User    *User `json:"user,omitempty"`
+}
+
+// Message represents a Telegram message.
+// See https://core.telegram.org/bots/api#message
+type Message struct {
+	MessageID            int                 `json:"message_id"`
+	MessageThreadID      int                 `json:"message_thread_id,omitempty"`
+	DirectMessageTopic   *DirectMessageTopic `json:"direct_message_topic,omitempty"`
+	BusinessConnectionId string              `json:"business_connection_id,omitempty"`
+	From                 *User               `json:"from,omitempty"`
+
+	SenderChat        *Chat  `json:"sender_chat,omitempty"`
+	SenderBoostCount  int    `json:"sender_boost_count,omitempty"`
+	SenderBusinessBot *User  `json:"sender_business_bot,omitempty"`
+	SenderTag         string `json:"sender_tag,omitempty"`
+	Chat              *Chat  `json:"chat,omitempty"`
+
+	IsTopicMessage     bool     `json:"is_topic_message,omitempty"`
+	IsAutomaticForward bool     `json:"is_automatic_forward,omitempty"`
+	IsFromOffline      bool     `json:"is_from_offline,omitempty"`
+	IsPaidPost         bool     `json:"is_paid_post,omitempty"`
+	MediaGroupId       string   `json:"media_group_id,omitempty"`
+	AuthorSignature    string   `json:"author_signature,omitempty"`
+	PaidStarCount      int      `json:"paid_star_count,omitempty"`
+	ReplyToMessage     *Message `json:"reply_to_message,omitempty"`
+
+	Text string `json:"text"`
+
+	Photo           extypes.Slice[*PhotoSize] `json:"photo,omitempty"`
+	Caption         string                    `json:"caption,omitempty"`
+	CaptionEntities []MessageEntity           `json:"caption_entities,omitempty"`
+
+	Date     int `json:"date"`
+	EditDate int `json:"edit_date"`
+
+	ReplyMarkup *MessageReplyMarkup `json:"reply_markup,omitempty"`
+
+	Entities           []MessageEntity     `json:"entities,omitempty"`
+	LinkPreviewOptions *LinkPreviewOptions `json:"link_preview_options,omitempty"`
+	SuggestedPostInfo  *SuggestedPostInfo  `json:"suggested_post_info,omitempty"`
+
+	EffectID string `json:"effect_id,omitempty"`
+}
+
+// InaccessibleMessage describes a message that was deleted or is otherwise inaccessible.
+// See https://core.telegram.org/bots/api#inaccessiblemessage
+type InaccessibleMessage struct {
+	Chat      Chat `json:"chat"`
+	MessageID int  `json:"message_id"`
+	Date      int  `json:"date"`
+}
+
+// MaybeInaccessibleMessage is a union type that can be either Message or InaccessibleMessage.
+// See https://core.telegram.org/bots/api#maybeinaccessiblemessage
+type MaybeInaccessibleMessage interface{ Message | InaccessibleMessage }
+
+// MessageEntityType represents the type of a message entity.
+type MessageEntityType string
+
+const (
+	MessageEntityMention              MessageEntityType = "mention"
+	MessageEntityHashtag              MessageEntityType = "hashtag"
+	MessageEntityCashtag              MessageEntityType = "cashtag"
+	MessageEntityBotCommand           MessageEntityType = "bot_command"
+	MessageEntityUrl                  MessageEntityType = "url"
+	MessageEntityEmail                MessageEntityType = "email"
+	MessageEntityPhoneNumber          MessageEntityType = "phone_number"
+	MessageEntityBold                 MessageEntityType = "bold"
+	MessageEntityItalic               MessageEntityType = "italic"
+	MessageEntityUnderline            MessageEntityType = "underline"
+	MessageEntityStrike               MessageEntityType = "strikethrough"
+	MessageEntitySpoiler              MessageEntityType = "spoiler"
+	MessageEntityBlockquote           MessageEntityType = "blockquote"
+	MessageEntityExpandableBlockquote MessageEntityType = "expandable_blockquote"
+	MessageEntityCode                 MessageEntityType = "code"
+	MessageEntityPre                  MessageEntityType = "pre"
+	MessageEntityTextLink             MessageEntityType = "text_link"
+	MessageEntityTextMention          MessageEntityType = "text_mention"
+	MessageEntityCustomEmoji          MessageEntityType = "custom_emoji"
+	MessageEntityDateTime             MessageEntityType = "date_time"
+)
+
+// MessageEntity represents one special entity in a text message.
+// See https://core.telegram.org/bots/api#messageentity
+type MessageEntity struct {
+	Type MessageEntityType `json:"type"`
+
+	Offset        int    `json:"offset"`
+	Length        int    `json:"length"`
+	URL           string `json:"url,omitempty"`
+	User          *User  `json:"user,omitempty"`
+	Language      string `json:"language,omitempty"`
+	CustomEmojiID string `json:"custom_emoji_id,omitempty"`
+
+	UnixTime       int    `json:"unix_time,omitempty"`
+	DateTimeFormat string `json:"date_time_format,omitempty"`
+}
+
+// ReplyParameters describes the parameters to use when replying to a message.
+// See https://core.telegram.org/bots/api#replyparameters
+type ReplyParameters struct {
+	MessageID int   `json:"message_id"`
+	ChatID    int64 `json:"chat_id,omitempty"`
+
+	AllowSendingWithoutReply bool             `json:"allow_sending_without_reply,omitempty"`
+	Quote                    string           `json:"quote,omitempty"`
+	QuoteParsingMode         string           `json:"quote_parsing_mode,omitempty"`
+	QuoteEntities            []*MessageEntity `json:"quote_entities,omitempty"`
+	QuotePosition            int              `json:"quote_position,omitempty"`
+	ChecklistTaskID          int              `json:"checklist_task_id,omitempty"`
+}
+
+// LinkPreviewOptions describes the options used for link preview generation.
+// See https://core.telegram.org/bots/api#linkpreviewoptions
+type LinkPreviewOptions struct {
+	IsDisabled       bool   `json:"is_disabled,omitempty"`
+	URL              string `json:"url,omitempty"`
+	PreferSmallMedia bool   `json:"prefer_small_media,omitempty"`
+	PreferLargeMedia bool   `json:"prefer_large_media,omitempty"`
+	ShowAboveText    bool   `json:"show_above_text,omitempty"`
+}
+
+// ReplyMarkup represents a custom keyboard or inline keyboard.
+// See https://core.telegram.org/bots/api#replymarkup
+type ReplyMarkup struct {
+	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard,omitempty"`
+
+	Keyboard              [][]KeyboardButton `json:"keyboard,omitempty"`
+	IsPersistent          bool               `json:"is_persistent,omitempty"`
+	ResizeKeyboard        bool               `json:"resize_keyboard,omitempty"`
+	OneTimeKeyboard       bool               `json:"one_time_keyboard,omitempty"`
+	InputFieldPlaceholder string             `json:"input_field_placeholder,omitempty"`
+	Selective             bool               `json:"selective,omitempty"`
+
+	RemoveKeyboard bool `json:"remove_keyboard,omitempty"`
+
+	ForceReply bool `json:"force_reply,omitempty"`
+}
+
+// InlineKeyboardMarkup represents an inline keyboard that appears right next to the message it belongs to.
+// See https://core.telegram.org/bots/api#inlinekeyboardmarkup
+type InlineKeyboardMarkup struct {
+	InlineKeyboard [][]InlineKeyboardButton `json:"inline_keyboard,omitempty"`
+}
+
+// KeyboardButtonStyle represents the style of a keyboard button.
+type KeyboardButtonStyle string
+
+const (
+	KeyboardButtonStyleDanger  KeyboardButtonStyle = "danger"
+	KeyboardButtonStyleSuccess KeyboardButtonStyle = "success"
+	KeyboardButtonStylePrimary KeyboardButtonStyle = "primary"
+)
+
+// KeyboardButton represents one button of the reply keyboard.
+// See https://core.telegram.org/bots/api#keyboardbutton
+type KeyboardButton struct {
+	Text              string                      `json:"text"`
+	IconCustomEmojiID string                      `json:"icon_custom_emoji_id,omitempty"`
+	Style             KeyboardButtonStyle         `json:"style,omitempty"`
+	RequestUsers      *KeyboardButtonRequestUsers `json:"request_users,omitempty"`
+	RequestChat       *KeyboardButtonRequestChat  `json:"request_chat,omitempty"`
+	RequestContact    bool                        `json:"request_contact,omitempty"`
+	RequestLocation   bool                        `json:"request_location,omitempty"`
+	RequestPoll       *KeyboardButtonPollType     `json:"request_poll,omitempty"`
+	WebApp            *WebAppInfo                 `json:"web_app,omitempty"`
+}
+
+// KeyboardButtonRequestUsers defines criteria used to request suitable users.
+// See https://core.telegram.org/bots/api#keyboardbuttonrequestusers
+type KeyboardButtonRequestUsers struct {
+	RequestID       int   `json:"request_id"`
+	UserIsBot       *bool `json:"user_is_bot,omitempty"`
+	UserIsPremium   *bool `json:"user_is_premium,omitempty"`
+	MaxQuantity     int   `json:"max_quantity,omitempty"`
+	RequestName     bool  `json:"request_name,omitempty"`
+	RequestUsername bool  `json:"request_username,omitempty"`
+	RequestPhoto    bool  `json:"request_photo,omitempty"`
+}
+
+// KeyboardButtonRequestChat defines criteria used to request a suitable chat.
+// See https://core.telegram.org/bots/api#keyboardbuttonrequestchat
+type KeyboardButtonRequestChat struct {
+	RequestID               int                      `json:"request_id"`
+	ChatIsChannel           bool                     `json:"chat_is_channel"`
+	ChatIsForum             *bool                    `json:"chat_is_forum,omitempty"`
+	ChatHasUsername         *bool                    `json:"chat_has_username,omitempty"`
+	ChatIsCreated           *bool                    `json:"chat_is_created,omitempty"`
+	UserAdministratorRights *ChatAdministratorRights `json:"user_administrator_rights,omitempty"`
+	BotAdministratorRights  *ChatAdministratorRights `json:"bot_administrator_rights,omitempty"`
+	BotIsMember             bool                     `json:"bot_is_member,omitempty"`
+	RequestTitle            bool                     `json:"request_title,omitempty"`
+	RequestUsername         bool                     `json:"request_username,omitempty"`
+	RequestPhoto            bool                     `json:"request_photo,omitempty"`
+}
+
+// KeyboardButtonPollType represents the type of a poll that may be created from a keyboard button.
+// See https://core.telegram.org/bots/api#keyboardbuttonpolltype
+type KeyboardButtonPollType struct {
+	Type PollType `json:"type,omitempty"`
+}
+
+// InlineKeyboardButton represents one button of an inline keyboard.
+// See https://core.telegram.org/bots/api#inlinekeyboardbutton
+type InlineKeyboardButton struct {
+	Text              string              `json:"text"`
+	URL               string              `json:"url,omitempty"`
+	CallbackData      string              `json:"callback_data,omitempty"`
+	Style             KeyboardButtonStyle `json:"style,omitempty"`
+	IconCustomEmojiID string              `json:"icon_custom_emoji_id,omitempty"`
+}
+
+// ReplyKeyboardMarkup represents a custom keyboard with reply options.
+// See https://core.telegram.org/bots/api#replykeyboardmarkup
+type ReplyKeyboardMarkup struct {
+	Keyboard              [][]KeyboardButton `json:"keyboard"`
+	IsPersistent          bool               `json:"is_persistent,omitempty"`
+	ResizeKeyboard        bool               `json:"resize_keyboard,omitempty"`
+	OneTimeKeyboard       bool               `json:"one_time_keyboard,omitempty"`
+	InputFieldPlaceholder string             `json:"input_field_placeholder,omitempty"`
+	Selective             bool               `json:"selective,omitempty"`
+}
+
+// CallbackQuery represents an incoming callback query from a callback button in an inline keyboard.
+// See https://core.telegram.org/bots/api#callbackquery
+type CallbackQuery struct {
+	ID              string   `json:"id"`
+	From            User     `json:"from"`
+	Message         *Message `json:"message,omitempty"`
+	InlineMessageID *string  `json:"inline_message_id,omitempty"`
+	ChatInstance    string   `json:"chat_instance,omitempty"`
+	Data            string   `json:"data,omitempty"`
+	GameShortName   string   `json:"game_short_name,omitempty"`
+}
+
+// InputPollOption contains information about one answer option in a poll to be sent.
+// See https://core.telegram.org/bots/api#inputpolloption
+type InputPollOption struct {
+	Text          string           `json:"text"`
+	TextParseMode ParseMode        `json:"text_parse_mode,omitempty"`
+	TextEntities  []*MessageEntity `json:"text_entities,omitempty"`
+}
+
+// PollType represents the type of a poll.
+type PollType string
+
+const (
+	PollTypeRegular PollType = "regular"
+	PollTypeQuiz    PollType = "quiz"
+)
+
+// InputChecklistTask describes a task in a checklist.
+type InputChecklistTask struct {
+	ID           int              `json:"id"`
+	Text         string           `json:"text"`
+	ParseMode    ParseMode        `json:"parse_mode,omitempty"`
+	TextEntities []*MessageEntity `json:"text_entities,omitempty"`
+}
+
+// InputChecklist represents a checklist to be sent.
+type InputChecklist struct {
+	Title                   string               `json:"title"`
+	ParseMode               ParseMode            `json:"parse_mode,omitempty"`
+	TitleEntities           []*MessageEntity     `json:"title_entities,omitempty"`
+	Tasks                   []InputChecklistTask `json:"tasks"`
+	OtherCanAddTasks        bool                 `json:"other_can_add_tasks,omitempty"`
+	OtherCanMarkTasksAsDone bool                 `json:"other_can_mark_tasks_as_done,omitempty"`
+}
+
+// ChatActionType represents the type of chat action.
+type ChatActionType string
+
+const (
+	ChatActionTyping          ChatActionType = "typing"
+	ChatActionUploadPhoto     ChatActionType = "upload_photo"
+	ChatActionUploadVideo     ChatActionType = "upload_video"
+	ChatActionUploadVoice     ChatActionType = "upload_voice"
+	ChatActionUploadDocument  ChatActionType = "upload_document"
+	ChatActionChooseSticker   ChatActionType = "choose_sticker"
+	ChatActionFindLocation    ChatActionType = "find_location"
+	ChatActionUploadVideoNote ChatActionType = "upload_video_note"
+	ChatActionUploadVideoNone ChatActionType = ChatActionUploadVideoNote
+)
+
+// MessageReactionUpdated represents a change of a reaction on a message.
+// See https://core.telegram.org/bots/api#messagereactionupdated
+type MessageReactionUpdated struct {
+	Chat        *Chat          `json:"chat"`
+	MessageID   int            `json:"message_id"`
+	User        *User          `json:"user,omitempty"`
+	ActorChat   *Chat          `json:"actor_chat"`
+	Date        int            `json:"date"`
+	OldReaction []ReactionType `json:"old_reaction"`
+	NewReaction []ReactionType `json:"new_reaction"`
+}
+
+// MessageReactionCountUpdated represents a change in the count of reactions on a message.
+// See https://core.telegram.org/bots/api#messagereactioncountupdated
+type MessageReactionCountUpdated struct {
+	Chat      *Chat            `json:"chat"`
+	MessageID int              `json:"message_id"`
+	Date      int              `json:"date"`
+	Reactions []*ReactionCount `json:"reactions"`
+}
+
+// ReactionType describes the type of a reaction.
+// See https://core.telegram.org/bots/api#reactiontype
+type ReactionType struct {
+	Type string `json:"type"`
+	// ReactionTypeEmoji
+	Emoji *string `json:"emoji,omitempty"`
+	// ReactionTypeCustomEmoji
+	CustomEmojiID *string `json:"custom_emoji_id,omitempty"`
+}
+
+// ReactionCount represents a reaction added to a message along with the number of times it was added.
+// See https://core.telegram.org/bots/api#reactioncount
+type ReactionCount struct {
+	Type       ReactionType `json:"type"`
+	TotalCount int          `json:"total_count"`
+}
+
+// SuggestedPostPrice represents the price of a suggested post.
+type SuggestedPostPrice struct {
+	Currency string `json:"currency"`
+	Amount   int    `json:"amount"`
+}
+
+// SuggestedPostInfo contains information about a suggested post.
+// See https://core.telegram.org/bots/api#suggestedpostinfo
+type SuggestedPostInfo struct {
+	State    string             `json:"state"` // "pending", "approved", or "declined"
+	Price    SuggestedPostPrice `json:"price"`
+	SendDate int                `json:"send_date"`
+}
+
+// SuggestedPostParameters holds parameters for suggesting a post.
+type SuggestedPostParameters struct {
+	Price    SuggestedPostPrice `json:"price"`
+	SendDate int                `json:"send_date"`
+}

tgapi/messages_types_test.go

@@ -0,0 +1,37 @@
+package tgapi
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestReplyKeyboardMarkupMarshalsKeyboardButtons(t *testing.T) {
+	markup := ReplyKeyboardMarkup{
+		Keyboard: [][]KeyboardButton{{
+			{
+				Text:        "Create poll",
+				RequestPoll: &KeyboardButtonPollType{Type: PollTypeQuiz},
+			},
+		}},
+	}
+
+	data, err := json.Marshal(markup)
+	if err != nil {
+		t.Fatalf("Marshal returned error: %v", err)
+	}
+
+	got := string(data)
+	if !strings.Contains(got, `"keyboard":[[{"text":"Create poll","request_poll":{"type":"quiz"}}]]`) {
+		t.Fatalf("unexpected reply keyboard JSON: %s", got)
+	}
+}
+
+func TestChatActionUploadVideoNoteValue(t *testing.T) {
+	if ChatActionUploadVideoNote != "upload_video_note" {
+		t.Fatalf("unexpected chat action value: %q", ChatActionUploadVideoNote)
+	}
+	if ChatActionUploadVideoNone != ChatActionUploadVideoNote {
+		t.Fatalf("expected deprecated alias to match upload_video_note, got %q", ChatActionUploadVideoNone)
+	}
+}

tgapi/methods.go

@@ -0,0 +1,136 @@
+package tgapi
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+
+	"git.nix13.pw/scuroneko/laniakea/utils"
+)
+
+// UpdateParams holds parameters for the getUpdates method.
+// See https://core.telegram.org/bots/api#getupdates
+type UpdateParams struct {
+	Offset         *int         `json:"offset,omitempty"`
+	Limit          *int         `json:"limit,omitempty"`
+	Timeout        *int         `json:"timeout,omitempty"`
+	AllowedUpdates []UpdateType `json:"allowed_updates,omitempty"`
+}
+
+// GetMe returns basic information about the bot.
+// See https://core.telegram.org/bots/api#getme
+func (api *API) GetMe() (User, error) {
+	req := NewRequest[User, EmptyParams]("getMe", NoParams)
+	return req.Do(api)
+}
+
+// LogOut logs the bot out from the cloud Bot API server.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#logout
+func (api *API) LogOut() (bool, error) {
+	req := NewRequest[bool, EmptyParams]("logOut", NoParams)
+	return req.Do(api)
+}
+
+// Close closes the bot instance on the local server.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#close
+func (api *API) Close() (bool, error) {
+	req := NewRequest[bool, EmptyParams]("close", NoParams)
+	return req.Do(api)
+}
+
+// GetUpdates receives incoming updates using long polling.
+// See https://core.telegram.org/bots/api#getupdates
+func (api *API) GetUpdates(params UpdateParams) ([]Update, error) {
+	req := NewRequest[[]Update]("getUpdates", params)
+	return req.Do(api)
+}
+
+// SetWebhookP holds parameters for the setWebhook method.
+// See https://core.telegram.org/bots/api#setwebhook
+type SetWebhookP struct {
+	URL                string       `json:"url"`
+	Certificate        string       `json:"certificate,omitempty"`
+	IPAddress          string       `json:"ip_address,omitempty"`
+	MaxConnections     int          `json:"max_connections,omitempty"`
+	AllowedUpdates     []UpdateType `json:"allowed_updates,omitempty"`
+	DropPendingUpdates bool         `json:"drop_pending_updates,omitempty"`
+	SecretToken        string       `json:"secret_token,omitempty"`
+}
+
+// SetWebhook sets a webhook URL for incoming updates.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setwebhook
+func (api *API) SetWebhook(params SetWebhookP) (bool, error) {
+	req := NewRequest[bool]("setWebhook", params)
+	return req.Do(api)
+}
+
+// DeleteWebhookP holds parameters for the deleteWebhook method.
+// See https://core.telegram.org/bots/api#deletewebhook
+type DeleteWebhookP struct {
+	DropPendingUpdates bool `json:"drop_pending_updates,omitempty"`
+}
+
+// DeleteWebhook removes the current webhook integration.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#deletewebhook
+func (api *API) DeleteWebhook(params DeleteWebhookP) (bool, error) {
+	req := NewRequest[bool]("deleteWebhook", params)
+	return req.Do(api)
+}
+
+// GetWebhookInfo returns the current webhook status.
+// See https://core.telegram.org/bots/api#getwebhookinfo
+func (api *API) GetWebhookInfo() (WebhookInfo, error) {
+	req := NewRequest[WebhookInfo]("getWebhookInfo", NoParams)
+	return req.Do(api)
+}
+
+// GetFileP holds parameters for the getFile method.
+// See https://core.telegram.org/bots/api#getfile
+type GetFileP struct {
+	FileId string `json:"file_id"`
+}
+
+// GetFile returns basic information about a file and prepares it for downloading.
+// See https://core.telegram.org/bots/api#getfile
+func (api *API) GetFile(params GetFileP) (File, error) {
+	req := NewRequest[File]("getFile", params)
+	return req.Do(api)
+}
+
+// GetFileByLink downloads a file from Telegram's file server using the provided file link.
+// The link is usually obtained from File.FilePath.
+// See https://core.telegram.org/bots/api#file
+func (api *API) GetFileByLink(link string) ([]byte, error) {
+	methodPrefix := ""
+	if api.useTestServer {
+		methodPrefix = "/test"
+	}
+	u := fmt.Sprintf("%s/file/bot%s%s/%s", api.apiUrl, api.token, methodPrefix, link)
+
+	req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, u, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", fmt.Sprintf("Laniakea/%s", utils.VersionString))
+
+	res, err := api.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		_ = res.Body.Close()
+	}()
+	if res.StatusCode < http.StatusOK || res.StatusCode >= http.StatusMultipleChoices {
+		body, readErr := io.ReadAll(io.LimitReader(res.Body, 4<<10))
+		if readErr != nil {
+			return nil, fmt.Errorf("unexpected status %d", res.StatusCode)
+		}
+		return nil, fmt.Errorf("unexpected status %d: %s", res.StatusCode, string(body))
+	}
+	return io.ReadAll(res.Body)
+}

tgapi/methods_test.go

@@ -0,0 +1,115 @@
+package tgapi
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+func TestGetFileByLinkUsesConfiguredAPIURL(t *testing.T) {
+	var gotPath string
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			gotPath = req.URL.Path
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(strings.NewReader("payload")),
+			}, nil
+		}),
+	}
+
+	api := NewAPI(
+		NewAPIOpts("token").
+			SetAPIUrl("https://example.test").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		if err := api.CloseApi(); err != nil {
+			t.Fatalf("CloseApi returned error: %v", err)
+		}
+	}()
+
+	data, err := api.GetFileByLink("files/report.txt")
+	if err != nil {
+		t.Fatalf("GetFileByLink returned error: %v", err)
+	}
+	if string(data) != "payload" {
+		t.Fatalf("unexpected payload: %q", string(data))
+	}
+	if gotPath != "/file/bottoken/files/report.txt" {
+		t.Fatalf("unexpected request path: %s", gotPath)
+	}
+}
+
+func TestGetFileByLinkReturnsHTTPStatusError(t *testing.T) {
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			return &http.Response{
+				StatusCode: http.StatusNotFound,
+				Body:       io.NopCloser(strings.NewReader("missing\n")),
+			}, nil
+		}),
+	}
+
+	api := NewAPI(
+		NewAPIOpts("token").
+			SetAPIUrl("https://example.test").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		if err := api.CloseApi(); err != nil {
+			t.Fatalf("CloseApi returned error: %v", err)
+		}
+	}()
+
+	_, err := api.GetFileByLink("files/report.txt")
+	if err == nil {
+		t.Fatal("expected error for non-2xx response")
+	}
+}
+
+func TestGetUpdatesOmitsAllowedUpdatesWhenEmpty(t *testing.T) {
+	var gotBody map[string]any
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			body, err := io.ReadAll(req.Body)
+			if err != nil {
+				t.Fatalf("failed to read request body: %v", err)
+			}
+			if err := json.Unmarshal(body, &gotBody); err != nil {
+				t.Fatalf("failed to decode request body: %v", err)
+			}
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(`{"ok":true,"result":[]}`)),
+			}, nil
+		}),
+	}
+
+	api := NewAPI(
+		NewAPIOpts("token").
+			SetAPIUrl("https://example.test").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		if err := api.CloseApi(); err != nil {
+			t.Fatalf("CloseApi returned error: %v", err)
+		}
+	}()
+
+	updates, err := api.GetUpdates(UpdateParams{})
+	if err != nil {
+		t.Fatalf("GetUpdates returned error: %v", err)
+	}
+	if len(updates) != 0 {
+		t.Fatalf("expected no updates, got %d", len(updates))
+	}
+	if _, exists := gotBody["allowed_updates"]; exists {
+		t.Fatalf("expected allowed_updates to be omitted, got %v", gotBody["allowed_updates"])
+	}
+}

tgapi/methods_types.go

@@ -0,0 +1,35 @@
+package tgapi
+
+// ParseMode represents the text formatting mode for message parsing.
+type ParseMode string
+
+const (
+	// ParseMDV2 enables MarkdownV2 style parsing.
+	ParseMDV2 ParseMode = "MarkdownV2"
+	// ParseHTML enables HTML style parsing.
+	ParseHTML ParseMode = "HTML"
+	// ParseMD enables legacy Markdown style parsing.
+	ParseMD ParseMode = "Markdown"
+	// ParseNone disables any parsing.
+	ParseNone ParseMode = "None"
+)
+
+// EmptyParams is a placeholder for methods that take no parameters.
+type EmptyParams struct{}
+
+// NoParams is a convenient instance of EmptyParams.
+var NoParams = EmptyParams{}
+
+// WebhookInfo describes the current webhook status.
+// See https://core.telegram.org/bots/api#webhookinfo
+type WebhookInfo struct {
+	URL                          string   `json:"url"`
+	HasCustomCertificate         bool     `json:"has_custom_certificate"`
+	PendingUpdateCount           int      `json:"pending_update_count"`
+	IPAddress                    string   `json:"ip_address,omitempty"`
+	LastErrorDate                int      `json:"last_error_date,omitempty"`
+	LastErrorMessage             string   `json:"last_error_message,omitempty"`
+	LastSynchronizationErrorDate int      `json:"last_synchronization_error_date,omitempty"`
+	MaxConnections               int      `json:"max_connections,omitempty"`
+	AllowedUpdates               []string `json:"allowed_updates,omitempty"`
+}

tgapi/passport_methods.go

@@ -0,0 +1,16 @@
+package tgapi
+
+// SetPassportDataErrorsP holds parameters for the setPassportDataErrors method.
+// See https://core.telegram.org/bots/api#setpassportdataerrors
+type SetPassportDataErrorsP struct {
+	UserID int64                  `json:"user_id"`
+	Errors []PassportElementError `json:"errors"`
+}
+
+// SetPassportDataErrors informs a user about Telegram Passport data errors.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setpassportdataerrors
+func (api *API) SetPassportDataErrors(params SetPassportDataErrorsP) (bool, error) {
+	req := NewRequest[bool]("setPassportDataErrors", params)
+	return req.Do(api)
+}

tgapi/passport_types.go

@@ -0,0 +1,5 @@
+package tgapi
+
+// PassportElementError is a JSON-serializable passport element error object.
+// See https://core.telegram.org/bots/api#passportelementerror
+type PassportElementError map[string]any

tgapi/payments_methods.go

@@ -0,0 +1,117 @@
+package tgapi
+
+// SendInvoiceP holds parameters for the sendInvoice method.
+// See https://core.telegram.org/bots/api#sendinvoice
+type SendInvoiceP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Title         string         `json:"title"`
+	Description   string         `json:"description"`
+	Payload       string         `json:"payload"`
+	ProviderToken string         `json:"provider_token,omitempty"`
+	Currency      string         `json:"currency"`
+	Prices        []LabeledPrice `json:"prices"`
+
+	MaxTipAmount        int    `json:"max_tip_amount,omitempty"`
+	SuggestedTipAmounts []int  `json:"suggested_tip_amounts,omitempty"`
+	StartParameter      string `json:"start_parameter,omitempty"`
+	ProviderData        string `json:"provider_data,omitempty"`
+	PhotoURL            string `json:"photo_url,omitempty"`
+	PhotoSize           int    `json:"photo_size,omitempty"`
+	PhotoWidth          int    `json:"photo_width,omitempty"`
+	PhotoHeight         int    `json:"photo_height,omitempty"`
+	NeedName            bool   `json:"need_name,omitempty"`
+	NeedPhoneNumber     bool   `json:"need_phone_number,omitempty"`
+	NeedEmail           bool   `json:"need_email,omitempty"`
+	NeedShippingAddress bool   `json:"need_shipping_address,omitempty"`
+	SendPhoneToProvider bool   `json:"send_phone_number_to_provider,omitempty"`
+	SendEmailToProvider bool   `json:"send_email_to_provider,omitempty"`
+	IsFlexible          bool   `json:"is_flexible,omitempty"`
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *InlineKeyboardMarkup    `json:"reply_markup,omitempty"`
+}
+
+// SendInvoice sends an invoice.
+// See https://core.telegram.org/bots/api#sendinvoice
+func (api *API) SendInvoice(params SendInvoiceP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendInvoice", params, params.ChatID)
+	return req.Do(api)
+}
+
+// CreateInvoiceLinkP holds parameters for the createInvoiceLink method.
+// See https://core.telegram.org/bots/api#createinvoicelink
+type CreateInvoiceLinkP struct {
+	BusinessConnectionID string `json:"business_connection_id,omitempty"`
+
+	Title         string         `json:"title"`
+	Description   string         `json:"description"`
+	Payload       string         `json:"payload"`
+	ProviderToken string         `json:"provider_token,omitempty"`
+	Currency      string         `json:"currency"`
+	Prices        []LabeledPrice `json:"prices"`
+
+	SubscriptionPeriod  int    `json:"subscription_period,omitempty"`
+	MaxTipAmount        int    `json:"max_tip_amount,omitempty"`
+	SuggestedTipAmounts []int  `json:"suggested_tip_amounts,omitempty"`
+	ProviderData        string `json:"provider_data,omitempty"`
+	PhotoURL            string `json:"photo_url,omitempty"`
+	PhotoSize           int    `json:"photo_size,omitempty"`
+	PhotoWidth          int    `json:"photo_width,omitempty"`
+	PhotoHeight         int    `json:"photo_height,omitempty"`
+	NeedName            bool   `json:"need_name,omitempty"`
+	NeedPhoneNumber     bool   `json:"need_phone_number,omitempty"`
+	NeedEmail           bool   `json:"need_email,omitempty"`
+	NeedShippingAddress bool   `json:"need_shipping_address,omitempty"`
+	SendPhoneToProvider bool   `json:"send_phone_number_to_provider,omitempty"`
+	SendEmailToProvider bool   `json:"send_email_to_provider,omitempty"`
+	IsFlexible          bool   `json:"is_flexible,omitempty"`
+}
+
+// CreateInvoiceLink creates an invoice link.
+// See https://core.telegram.org/bots/api#createinvoicelink
+func (api *API) CreateInvoiceLink(params CreateInvoiceLinkP) (string, error) {
+	req := NewRequest[string]("createInvoiceLink", params)
+	return req.Do(api)
+}
+
+// AnswerShippingQueryP holds parameters for the answerShippingQuery method.
+// See https://core.telegram.org/bots/api#answershippingquery
+type AnswerShippingQueryP struct {
+	ShippingQueryID string           `json:"shipping_query_id"`
+	OK              bool             `json:"ok"`
+	ShippingOptions []ShippingOption `json:"shipping_options,omitempty"`
+	ErrorMessage    string           `json:"error_message,omitempty"`
+}
+
+// AnswerShippingQuery answers a shipping query.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#answershippingquery
+func (api *API) AnswerShippingQuery(params AnswerShippingQueryP) (bool, error) {
+	req := NewRequest[bool]("answerShippingQuery", params)
+	return req.Do(api)
+}
+
+// AnswerPreCheckoutQueryP holds parameters for the answerPreCheckoutQuery method.
+// See https://core.telegram.org/bots/api#answerprecheckoutquery
+type AnswerPreCheckoutQueryP struct {
+	PreCheckoutQueryID string `json:"pre_checkout_query_id"`
+	OK                 bool   `json:"ok"`
+	ErrorMessage       string `json:"error_message,omitempty"`
+}
+
+// AnswerPreCheckoutQuery answers a pre-checkout query.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#answerprecheckoutquery
+func (api *API) AnswerPreCheckoutQuery(params AnswerPreCheckoutQueryP) (bool, error) {
+	req := NewRequest[bool]("answerPreCheckoutQuery", params)
+	return req.Do(api)
+}

tgapi/payments_types.go

@@ -0,0 +1,16 @@
+package tgapi
+
+// LabeledPrice represents a price portion.
+// See https://core.telegram.org/bots/api#labeledprice
+type LabeledPrice struct {
+	Label  string `json:"label"`
+	Amount int    `json:"amount"`
+}
+
+// ShippingOption represents one shipping option.
+// See https://core.telegram.org/bots/api#shippingoption
+type ShippingOption struct {
+	ID     string         `json:"id"`
+	Title  string         `json:"title"`
+	Prices []LabeledPrice `json:"prices"`
+}

tgapi/pool.go

@@ -0,0 +1,175 @@
+package tgapi
+
+import (
+	"context"
+	"sync"
+)
+
+// workerPool — приватная структура, управляющая пулом воркеров.
+// Внешний код не может создавать или напрямую взаимодействовать с этой структурой.
+// Используется только через экспортируемые методы newWorkerPool, start, stop, submit.
+type workerPool struct {
+	taskCh    chan requestEnvelope // канал для принятия задач (буферизованный)
+	queueSize int                  // максимальный размер очереди
+	workers   int                  // количество воркеров (горутин)
+	wg        sync.WaitGroup       // синхронизирует завершение всех воркеров при остановке
+	quit      chan struct{}        // канал для сигнала остановки
+	stopOnce  sync.Once            // гарантирует идемпотентную остановку пула
+	started   bool                 // флаг, указывающий, запущен ли пул
+	stopped   bool                 // флаг, указывающий, что пул остановлен
+	startedMu sync.Mutex           // мьютекс для безопасного доступа к started
+}
+
+// requestEnvelope — приватная структура, инкапсулирующая задачу и канал для результата.
+// Используется только внутри пакета для передачи задач воркерам.
+type requestEnvelope struct {
+	ctx      context.Context                    // контекст конкретной задачи
+	doFunc   func(context.Context) (any, error) // функция, выполняющая запрос
+	resultCh chan requestResult                 // канал, через который воркер вернёт результат
+}
+
+// requestResult — приватная структура, представляющая результат выполнения задачи.
+// Внешний код получает его через канал, но не знает структуры — только через <-chan requestResult.
+type requestResult struct {
+	value any   // значение, возвращённое задачей
+	err   error // ошибка, если возникла
+}
+
+// newWorkerPool создаёт новый пул воркеров с заданным количеством горутин и размером очереди.
+// Это единственный способ создать workerPool — внешний код не может создать его напрямую.
+func newWorkerPool(workers int, queueSize int) *workerPool {
+	if workers <= 0 {
+		workers = 1 // защита от некорректных значений
+	}
+	if queueSize <= 0 {
+		queueSize = 100 // разумный дефолт
+	}
+
+	return &workerPool{
+		taskCh:    make(chan requestEnvelope, queueSize),
+		queueSize: queueSize,
+		workers:   workers,
+		quit:      make(chan struct{}),
+	}
+}
+
+// start запускает воркеры (горутины), которые будут обрабатывать задачи из очереди.
+// Метод идемпотентен: если пул уже запущен — ничего не делает.
+// Должен вызываться перед первым вызовом submit.
+func (p *workerPool) start() {
+	p.startedMu.Lock()
+	defer p.startedMu.Unlock()
+	if p.started {
+		return // уже запущен — ничего не делаем
+	}
+	p.started = true
+
+	// Запускаем воркеры — каждый будет обрабатывать задачи в бесконечном цикле
+	for i := 0; i < p.workers; i++ {
+		p.wg.Add(1)
+		go p.worker() // запускаем горутину
+	}
+}
+
+// stop останавливает пул воркеров.
+// Отправляет сигнал остановки через quit-канал и ждёт завершения всех активных задач.
+// Безопасно вызывать многократно — после остановки повторные вызовы не имеют эффекта.
+func (p *workerPool) stop() {
+	p.stopOnce.Do(func() {
+		p.startedMu.Lock()
+		p.stopped = true
+		p.started = false
+		close(p.quit) // сигнал для всех воркеров — выйти из цикла
+		p.startedMu.Unlock()
+
+		p.wg.Wait() // ждём, пока все воркеры завершатся
+	})
+}
+
+// submit отправляет задачу в очередь и возвращает канал, через который будет получен результат.
+// Если очередь переполнена — возвращает ErrPoolQueueFull.
+// Канал результата имеет буфер 1, чтобы не блокировать воркера при записи.
+// Контекст используется для отмены задачи, если клиент отменил запрос до отправки.
+func (p *workerPool) submit(ctx context.Context, do func(context.Context) (any, error)) (<-chan requestResult, error) {
+	p.startedMu.Lock()
+	if p.stopped || !p.started {
+		p.startedMu.Unlock()
+		return nil, ErrPoolStopped
+	}
+
+	// Проверяем, не превышена ли очередь
+	if len(p.taskCh) >= p.queueSize {
+		p.startedMu.Unlock()
+		return nil, ErrPoolQueueFull
+	}
+
+	// Создаём канал для результата — буферизованный, чтобы не блокировать воркера
+	resultCh := make(chan requestResult, 1)
+
+	// Создаём обёртку задачи
+	envelope := requestEnvelope{
+		ctx:      ctx,
+		doFunc:   do,
+		resultCh: resultCh,
+	}
+
+	// Пытаемся отправить задачу в очередь
+	select {
+	case <-ctx.Done():
+		p.startedMu.Unlock()
+		// Клиент отменил операцию до отправки — возвращаем ошибку отмены
+		return nil, ctx.Err()
+	case p.taskCh <- envelope:
+		p.startedMu.Unlock()
+		// Успешно отправлено — возвращаем канал для чтения результата
+		return resultCh, nil
+	default:
+		p.startedMu.Unlock()
+		// Очередь переполнена — не должно происходить при проверке len(p.taskCh), но на всякий случай
+		return nil, ErrPoolQueueFull
+	}
+}
+
+// worker — приватная горутина, выполняющая задачи из очереди.
+// Каждый воркер работает в бесконечном цикле, пока не получит сигнал остановки.
+// При получении задачи:
+//   - вызывает doFunc с контекстом
+//   - записывает результат в resultCh
+//   - закрывает канал, чтобы клиент мог прочитать и завершить
+//
+// После закрытия quit-канала — воркер завершает работу.
+func (p *workerPool) worker() {
+	defer p.wg.Done() // уменьшаем WaitGroup при завершении горутины
+
+	for {
+		select {
+		case <-p.quit:
+			// Получен сигнал остановки — дренируем очередь и выходим.
+			// После stop() новые задачи не принимаются.
+			for {
+				select {
+				case envelope := <-p.taskCh:
+					p.executeEnvelope(envelope)
+				default:
+					return
+				}
+			}
+
+		case envelope := <-p.taskCh:
+			p.executeEnvelope(envelope)
+		}
+	}
+}
+
+func (p *workerPool) executeEnvelope(envelope requestEnvelope) {
+	// Выполняем задачу с переданным контекстом (клиентский или общий)
+	value, err := envelope.doFunc(envelope.ctx)
+
+	// Записываем результат в канал — не блокируем, т.к. буфер 1
+	envelope.resultCh <- requestResult{
+		value: value,
+		err:   err,
+	}
+	// Закрываем канал — клиент знает, что результат пришёл и больше не будет
+	close(envelope.resultCh)
+}

tgapi/stars_methods.go

@@ -0,0 +1,53 @@
+package tgapi
+
+// GetStarTransactionsP holds parameters for the getStarTransactions method.
+// See https://core.telegram.org/bots/api#getstartransactions
+type GetStarTransactionsP struct {
+	Offset int `json:"offset,omitempty"`
+	Limit  int `json:"limit,omitempty"`
+}
+
+// GetMyStarBalance returns the bot's Telegram Star balance.
+// See https://core.telegram.org/bots/api#getmystarbalance
+func (api *API) GetMyStarBalance() (StarAmount, error) {
+	req := NewRequest[StarAmount]("getMyStarBalance", NoParams)
+	return req.Do(api)
+}
+
+// GetStarTransactions returns Telegram Star transactions for the bot.
+// See https://core.telegram.org/bots/api#getstartransactions
+func (api *API) GetStarTransactions(params GetStarTransactionsP) (StarTransactions, error) {
+	req := NewRequest[StarTransactions]("getStarTransactions", params)
+	return req.Do(api)
+}
+
+// RefundStarPaymentP holds parameters for the refundStarPayment method.
+// See https://core.telegram.org/bots/api#refundstarpayment
+type RefundStarPaymentP struct {
+	UserID                  int64  `json:"user_id"`
+	TelegramPaymentChargeID string `json:"telegram_payment_charge_id"`
+}
+
+// RefundStarPayment refunds a successful Telegram Stars payment.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#refundstarpayment
+func (api *API) RefundStarPayment(params RefundStarPaymentP) (bool, error) {
+	req := NewRequest[bool]("refundStarPayment", params)
+	return req.Do(api)
+}
+
+// EditUserStarSubscriptionP holds parameters for the editUserStarSubscription method.
+// See https://core.telegram.org/bots/api#edituserstarsubscription
+type EditUserStarSubscriptionP struct {
+	UserID                  int64  `json:"user_id"`
+	TelegramPaymentChargeID string `json:"telegram_payment_charge_id"`
+	IsCanceled              bool   `json:"is_canceled"`
+}
+
+// EditUserStarSubscription cancels or re-enables a user star subscription extension.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#edituserstarsubscription
+func (api *API) EditUserStarSubscription(params EditUserStarSubscriptionP) (bool, error) {
+	req := NewRequest[bool]("editUserStarSubscription", params)
+	return req.Do(api)
+}

tgapi/stars_types.go

@@ -0,0 +1,18 @@
+package tgapi
+
+// StarTransaction describes a Telegram Star transaction.
+// See https://core.telegram.org/bots/api#startransaction
+type StarTransaction struct {
+	ID             string         `json:"id"`
+	Amount         int            `json:"amount"`
+	NanostarAmount int            `json:"nanostar_amount,omitempty"`
+	Date           int            `json:"date"`
+	Source         map[string]any `json:"source,omitempty"`
+	Receiver       map[string]any `json:"receiver,omitempty"`
+}
+
+// StarTransactions contains a list of Telegram Star transactions.
+// See https://core.telegram.org/bots/api#startransactions
+type StarTransactions struct {
+	Transactions []StarTransaction `json:"transactions"`
+}

tgapi/stickers_methods.go

@@ -0,0 +1,257 @@
+package tgapi
+
+// SendStickerP holds parameters for the sendSticker method.
+// See https://core.telegram.org/bots/api#sendsticker
+type SendStickerP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Sticker             string `json:"sticker"`
+	Emoji               string `json:"emoji,omitempty"`
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+}
+
+// SendSticker sends a static .WEBP, animated .TGS, or video .WEBM sticker.
+// See https://core.telegram.org/bots/api#sendsticker
+func (api *API) SendSticker(params SendStickerP) (Message, error) {
+	req := NewRequestWithChatID[Message]("sendSticker", params, params.ChatID)
+	return req.Do(api)
+}
+
+// GetStickerSetP holds parameters for the getStickerSet method.
+// See https://core.telegram.org/bots/api#getstickerset
+type GetStickerSetP struct {
+	Name string `json:"name"`
+}
+
+// GetStickerSet returns a sticker set by its name.
+// See https://core.telegram.org/bots/api#getstickerset
+func (api *API) GetStickerSet(params GetStickerSetP) (StickerSet, error) {
+	req := NewRequest[StickerSet]("getStickerSet", params)
+	return req.Do(api)
+}
+
+// GetCustomEmojiStickersP holds parameters for the getCustomEmojiStickers method.
+// See https://core.telegram.org/bots/api#getcustomemojistickers
+type GetCustomEmojiStickersP struct {
+	CustomEmojiIDs []string `json:"custom_emoji_ids"`
+}
+
+// GetCustomEmojiStickers returns information about custom emoji stickers by their IDs.
+// See https://core.telegram.org/bots/api#getcustomemojistickers
+func (api *API) GetCustomEmojiStickers(params GetCustomEmojiStickersP) ([]Sticker, error) {
+	req := NewRequest[[]Sticker]("getCustomEmojiStickers", params)
+	return req.Do(api)
+}
+
+// UploadStickerFileP holds parameters for the uploadStickerFile method.
+// See https://core.telegram.org/bots/api#uploadstickerfile
+type UploadStickerFileP struct {
+	UserID        int64              `json:"user_id"`
+	StickerFormat InputStickerFormat `json:"sticker_format"`
+}
+
+// UploadStickerFile uploads a sticker file for later use in sticker set methods.
+// sticker is the file to upload.
+// See https://core.telegram.org/bots/api#uploadstickerfile
+func (api *API) UploadStickerFile(params UploadStickerFileP, sticker UploaderFile) (File, error) {
+	uploader := NewUploader(api)
+	defer func() {
+		_ = uploader.Close()
+	}()
+	req := NewUploaderRequest[File]("uploadStickerFile", params, sticker.SetType(UploaderStickerType))
+	return req.Do(uploader)
+}
+
+// CreateNewStickerSetP holds parameters for the createNewStickerSet method.
+// See https://core.telegram.org/bots/api#createnewstickerset
+type CreateNewStickerSetP struct {
+	UserID int64  `json:"user_id"`
+	Name   string `json:"name"`
+	Title  string `json:"title"`
+
+	Stickers        []InputSticker `json:"stickers"`
+	StickerType     StickerType    `json:"sticker_type,omitempty"`
+	NeedsRepainting bool           `json:"needs_repainting,omitempty"`
+}
+
+// CreateNewStickerSet creates a new sticker set owned by a user.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#createnewstickerset
+func (api *API) CreateNewStickerSet(params CreateNewStickerSetP) (bool, error) {
+	req := NewRequest[bool]("createNewStickerSet", params)
+	return req.Do(api)
+}
+
+// AddStickerToSetP holds parameters for the addStickerToSet method.
+// See https://core.telegram.org/bots/api#addstickertoset
+type AddStickerToSetP struct {
+	UserID  int64        `json:"user_id"`
+	Name    string       `json:"name"`
+	Sticker InputSticker `json:"sticker"`
+}
+
+// AddStickerToSet adds a new sticker to a set created by the bot.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#addstickertoset
+func (api *API) AddStickerToSet(params AddStickerToSetP) (bool, error) {
+	req := NewRequest[bool]("addStickerToSet", params)
+	return req.Do(api)
+}
+
+// SetStickerPositionInSetP holds parameters for the setStickerPositionInSet method.
+// See https://core.telegram.org/bots/api#setstickerpositioninset
+type SetStickerPositionInSetP struct {
+	Sticker  string `json:"sticker"`
+	Position int    `json:"position"`
+}
+
+// SetStickerPositionInSet moves a sticker in a set to a specific position.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setstickerpositioninset
+func (api *API) SetStickerPositionInSet(params SetStickerPositionInSetP) (bool, error) {
+	req := NewRequest[bool]("setStickerPositionInSet", params)
+	return req.Do(api)
+}
+
+// DeleteStickerFromSetP holds parameters for the deleteStickerFromSet method.
+// See https://core.telegram.org/bots/api#deletestickerfromset
+type DeleteStickerFromSetP struct {
+	Sticker string `json:"sticker"`
+}
+
+// DeleteStickerFromSet deletes a sticker from a set created by the bot.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#deletestickerfromset
+func (api *API) DeleteStickerFromSet(params DeleteStickerFromSetP) (bool, error) {
+	req := NewRequest[bool]("deleteStickerFromSet", params)
+	return req.Do(api)
+}
+
+// ReplaceStickerInSetP holds parameters for the replaceStickerInSet method.
+// See https://core.telegram.org/bots/api#replacestickerinset
+type ReplaceStickerInSetP struct {
+	UserID     int64        `json:"user_id"`
+	Name       string       `json:"name"`
+	OldSticker string       `json:"old_sticker"`
+	Sticker    InputSticker `json:"sticker"`
+}
+
+// ReplaceStickerInSet replaces an existing sticker in a set with a new one.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#replacestickerinset
+func (api *API) ReplaceStickerInSet(params ReplaceStickerInSetP) (bool, error) {
+	req := NewRequest[bool]("replaceStickerInSet", params)
+	return req.Do(api)
+}
+
+// SetStickerEmojiListP holds parameters for the setStickerEmojiList method.
+// See https://core.telegram.org/bots/api#setstickeremojilist
+type SetStickerEmojiListP struct {
+	Sticker   string   `json:"sticker"`
+	EmojiList []string `json:"emoji_list"`
+}
+
+// SetStickerEmojiList changes the list of emoji associated with a sticker.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setstickeremojilist
+func (api *API) SetStickerEmojiList(params SetStickerEmojiListP) (bool, error) {
+	req := NewRequest[bool]("setStickerEmojiList", params)
+	return req.Do(api)
+}
+
+// SetStickerKeywordsP holds parameters for the setStickerKeywords method.
+// See https://core.telegram.org/bots/api#setstickerkeywords
+type SetStickerKeywordsP struct {
+	Sticker  string   `json:"sticker"`
+	Keywords []string `json:"keywords"`
+}
+
+// SetStickerKeywords changes the keywords of a sticker.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setstickerkeywords
+func (api *API) SetStickerKeywords(params SetStickerKeywordsP) (bool, error) {
+	req := NewRequest[bool]("setStickerKeywords", params)
+	return req.Do(api)
+}
+
+// SetStickerMaskPositionP holds parameters for the setStickerMaskPosition method.
+// See https://core.telegram.org/bots/api#setstickermaskposition
+type SetStickerMaskPositionP struct {
+	Sticker      string        `json:"sticker"`
+	MaskPosition *MaskPosition `json:"mask_position,omitempty"`
+}
+
+// SetStickerMaskPosition changes the mask position of a mask sticker.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setstickermaskposition
+func (api *API) SetStickerMaskPosition(params SetStickerMaskPositionP) (bool, error) {
+	req := NewRequest[bool]("setStickerMaskPosition", params)
+	return req.Do(api)
+}
+
+// SetStickerSetTitleP holds parameters for the setStickerSetTitle method.
+// See https://core.telegram.org/bots/api#setstickersettitle
+type SetStickerSetTitleP struct {
+	Name  string `json:"name"`
+	Title string `json:"title"`
+}
+
+// SetStickerSetTitle sets the title of a sticker set created by the bot.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setstickersettitle
+func (api *API) SetStickerSetTitle(params SetStickerSetTitleP) (bool, error) {
+	req := NewRequest[bool]("setStickerSetTitle", params)
+	return req.Do(api)
+}
+
+// SetStickerSetThumbnailP holds parameters for the setStickerSetThumbnail method.
+// See https://core.telegram.org/bots/api#setstickersetthumbnail
+type SetStickerSetThumbnailP struct {
+	Name      string             `json:"name"`
+	UserID    int64              `json:"user_id"`
+	Thumbnail string             `json:"thumbnail"`
+	Format    InputStickerFormat `json:"format"`
+}
+
+// SetStickerSetThumbnail sets the thumbnail of a sticker set.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setstickersetthumbnail
+func (api *API) SetStickerSetThumbnail(params SetStickerSetThumbnailP) (bool, error) {
+	req := NewRequest[bool]("setStickerSetThumbnail", params)
+	return req.Do(api)
+}
+
+// SetCustomEmojiStickerSetThumbnailP holds parameters for the setCustomEmojiStickerSetThumbnail method.
+// See https://core.telegram.org/bots/api#setcustomemojistickersetthumbnail
+type SetCustomEmojiStickerSetThumbnailP struct {
+	Name          string `json:"name"`
+	CustomEmojiID string `json:"custom_emoji_id,omitempty"`
+}
+
+// SetCustomEmojiStickerSetThumbnail sets the thumbnail of a custom emoji sticker set.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#setcustomemojistickersetthumbnail
+func (api *API) SetCustomEmojiStickerSetThumbnail(params SetCustomEmojiStickerSetThumbnailP) (bool, error) {
+	req := NewRequest[bool]("setCustomEmojiStickerSetThumbnail", params)
+	return req.Do(api)
+}
+
+// DeleteStickerSetP holds parameters for the deleteStickerSet method.
+// See https://core.telegram.org/bots/api#deletestickerset
+type DeleteStickerSetP struct {
+	Name string `json:"name"`
+}
+
+// DeleteStickerSet deletes a sticker set created by the bot.
+// Returns True on success.
+// See https://core.telegram.org/bots/api#deletestickerset
+func (api *API) DeleteStickerSet(params DeleteStickerSetP) (bool, error) {
+	req := NewRequest[bool]("deleteStickerSet", params)
+	return req.Do(api)
+}

tgapi/stickers_types.go

@@ -0,0 +1,88 @@
+package tgapi
+
+// MaskPositionPoint represents the part of the face where a mask should be placed.
+type MaskPositionPoint string
+
+const (
+	// MaskPositionForehead places the mask on the forehead.
+	MaskPositionForehead MaskPositionPoint = "forehead"
+	// MaskPositionEyes places the mask on the eyes.
+	MaskPositionEyes MaskPositionPoint = "eyes"
+	// MaskPositionMouth places the mask on the mouth.
+	MaskPositionMouth MaskPositionPoint = "mouth"
+	// MaskPositionChin places the mask on the chin.
+	MaskPositionChin MaskPositionPoint = "chin"
+)
+
+// MaskPosition describes the position on faces where a mask should be placed by default.
+// See https://core.telegram.org/bots/api#maskposition
+type MaskPosition struct {
+	Point  MaskPositionPoint `json:"point"`
+	XShift float32           `json:"x_shift"`
+	YShift float32           `json:"y_shift"`
+	Scale  float32           `json:"scale"`
+}
+
+// StickerType represents the type of a sticker.
+type StickerType string
+
+const (
+	// StickerTypeRegular is a regular sticker.
+	StickerTypeRegular StickerType = "regular"
+	// StickerTypeMask is a mask sticker that can be placed on faces.
+	StickerTypeMask StickerType = "mask"
+	// StickerTypeCustomEmoji is a custom emoji sticker.
+	StickerTypeCustomEmoji StickerType = "custom_emoji"
+)
+
+// Sticker represents a sticker.
+// See https://core.telegram.org/bots/api#sticker
+type Sticker struct {
+	FileId       string      `json:"file_id"`
+	FileUniqueId string      `json:"file_unique_id"`
+	Type         StickerType `json:"type"`
+	Width        int         `json:"width"`
+	Height       int         `json:"height"`
+	IsAnimated   bool        `json:"is_animated"`
+	IsVideo      bool        `json:"is_video"`
+
+	Thumbnail      *PhotoSize    `json:"thumbnail,omitempty"`
+	Emoji          *string       `json:"emoji,omitempty"`
+	SetName        *string       `json:"set_name,omitempty"`
+	MaskPosition   *MaskPosition `json:"mask_position,omitempty"`
+	CustomEmojiID  *string       `json:"custom_emoji_id,omitempty"`
+	NeedRepainting *bool         `json:"need_repainting,omitempty"`
+	FileSize       *int64        `json:"file_size,omitempty"`
+}
+
+// StickerSet represents a sticker set.
+// See https://core.telegram.org/bots/api#stickerset
+type StickerSet struct {
+	Name        string      `json:"name"`
+	Title       string      `json:"title"`
+	StickerType StickerType `json:"sticker_type"`
+	Stickers    []Sticker   `json:"stickers"`
+	Thumbnail   *PhotoSize  `json:"thumbnail,omitempty"`
+}
+
+// InputStickerFormat represents the format of an input sticker.
+type InputStickerFormat string
+
+const (
+	// InputStickerFormatStatic is a static sticker (WEBP).
+	InputStickerFormatStatic InputStickerFormat = "static"
+	// InputStickerFormatAnimated is an animated sticker (TGS).
+	InputStickerFormatAnimated InputStickerFormat = "animated"
+	// InputStickerFormatVideo is a video sticker (WEBM).
+	InputStickerFormatVideo InputStickerFormat = "video"
+)
+
+// InputSticker describes a sticker to be added to a sticker set.
+// See https://core.telegram.org/bots/api#inputsticker
+type InputSticker struct {
+	Sticker      string             `json:"sticker"`
+	Format       InputStickerFormat `json:"format"`
+	EmojiList    []string           `json:"emoji_list"`
+	MaskPosition *MaskPosition      `json:"mask_position,omitempty"`
+	Keywords     []string           `json:"keywords,omitempty"`
+}

tgapi/types.go

@@ -0,0 +1,413 @@
+package tgapi
+
+import "encoding/json"
+
+// UpdateType represents the type of incoming update.
+type UpdateType string
+
+const (
+	// UpdateTypeMessage is a regular message update.
+	UpdateTypeMessage UpdateType = "message"
+	// UpdateTypeEditedMessage is an edited message update.
+	UpdateTypeEditedMessage UpdateType = "edited_message"
+	// UpdateTypeChannelPost is a channel post update.
+	UpdateTypeChannelPost UpdateType = "channel_post"
+	// UpdateTypeEditedChannelPost is an edited channel post update.
+	UpdateTypeEditedChannelPost UpdateType = "edited_channel_post"
+	// UpdateTypeMessageReaction is a message reaction update.
+	UpdateTypeMessageReaction UpdateType = "message_reaction"
+	// UpdateTypeMessageReactionCount is a message reaction count update.
+	UpdateTypeMessageReactionCount UpdateType = "message_reaction_count"
+
+	// UpdateTypeBusinessConnection is a business connection update.
+	UpdateTypeBusinessConnection UpdateType = "business_connection"
+	// UpdateTypeBusinessMessage is a business message update.
+	UpdateTypeBusinessMessage UpdateType = "business_message"
+	// UpdateTypeEditedBusinessMessage is an edited business message update.
+	UpdateTypeEditedBusinessMessage UpdateType = "edited_business_message"
+	// UpdateTypeDeletedBusinessMessages is a deleted business messages update.
+	UpdateTypeDeletedBusinessMessages UpdateType = "deleted_business_messages"
+	// UpdateTypeDeletedBusinessMessage is kept as a backward-compatible alias.
+	UpdateTypeDeletedBusinessMessage UpdateType = UpdateTypeDeletedBusinessMessages
+
+	// UpdateTypeInlineQuery is an inline query update.
+	UpdateTypeInlineQuery UpdateType = "inline_query"
+	// UpdateTypeChosenInlineResult is a chosen inline result update.
+	UpdateTypeChosenInlineResult UpdateType = "chosen_inline_result"
+	// UpdateTypeCallbackQuery is a callback query update.
+	UpdateTypeCallbackQuery UpdateType = "callback_query"
+	// UpdateTypeShippingQuery is a shipping query update.
+	UpdateTypeShippingQuery UpdateType = "shipping_query"
+	// UpdateTypePreCheckoutQuery is a pre-checkout query update.
+	UpdateTypePreCheckoutQuery UpdateType = "pre_checkout_query"
+	// UpdateTypePurchasedPaidMedia is a purchased paid media update.
+	UpdateTypePurchasedPaidMedia UpdateType = "purchased_paid_media"
+	// UpdateTypePoll is a poll update.
+	UpdateTypePoll UpdateType = "poll"
+	// UpdateTypePollAnswer is a poll answer update.
+	UpdateTypePollAnswer UpdateType = "poll_answer"
+	// UpdateTypeMyChatMember is a my chat member update.
+	UpdateTypeMyChatMember UpdateType = "my_chat_member"
+	// UpdateTypeChatMember is a chat member update.
+	UpdateTypeChatMember UpdateType = "chat_member"
+	// UpdateTypeChatJoinRequest is a chat join request update.
+	UpdateTypeChatJoinRequest UpdateType = "chat_join_request"
+	// UpdateTypeChatBoost is a chat boost update.
+	UpdateTypeChatBoost UpdateType = "chat_boost"
+	// UpdateTypeRemovedChatBoost is a removed chat boost update.
+	UpdateTypeRemovedChatBoost UpdateType = "removed_chat_boost"
+)
+
+// Update represents an incoming update from Telegram.
+// See https://core.telegram.org/bots/api#update
+type Update struct {
+	UpdateID          int      `json:"update_id"`
+	Message           *Message `json:"message,omitempty"`
+	EditedMessage     *Message `json:"edited_message,omitempty"`
+	ChannelPost       *Message `json:"channel_post,omitempty"`
+	EditedChannelPost *Message `json:"edited_channel_post,omitempty"`
+
+	BusinessConnection      *BusinessConnection          `json:"business_connection,omitempty"`
+	BusinessMessage         *Message                     `json:"business_message,omitempty"`
+	EditedBusinessMessage   *Message                     `json:"edited_business_message,omitempty"`
+	DeletedBusinessMessages *BusinessMessagesDeleted     `json:"deleted_business_messages,omitempty"`
+	DeletedBusinessMessage  *BusinessMessagesDeleted     `json:"-"`
+	MessageReaction         *MessageReactionUpdated      `json:"message_reaction,omitempty"`
+	MessageReactionCount    *MessageReactionCountUpdated `json:"message_reaction_count,omitempty"`
+
+	InlineQuery        *InlineQuery        `json:"inline_query,omitempty"`
+	ChosenInlineResult *ChosenInlineResult `json:"chosen_inline_result,omitempty"`
+	CallbackQuery      *CallbackQuery      `json:"callback_query,omitempty"`
+	ShippingQuery      *ShippingQuery      `json:"shipping_query,omitempty"`
+	PreCheckoutQuery   *PreCheckoutQuery   `json:"pre_checkout_query,omitempty"`
+	PurchasedPaidMedia *PaidMediaPurchased `json:"purchased_paid_media,omitempty"`
+
+	Poll             *Poll              `json:"poll,omitempty"`
+	PollAnswer       *PollAnswer        `json:"poll_answer,omitempty"`
+	MyChatMember     *ChatMemberUpdated `json:"my_chat_member,omitempty"`
+	ChatMember       *ChatMemberUpdated `json:"chat_member,omitempty"`
+	ChatJoinRequest  *ChatJoinRequest   `json:"chat_join_request,omitempty"`
+	ChatBoost        *ChatBoostUpdated  `json:"chat_boost,omitempty"`
+	RemovedChatBoost *ChatBoostRemoved  `json:"removed_chat_boost,omitempty"`
+}
+
+func (u *Update) syncDeletedBusinessMessages() {
+	if u.DeletedBusinessMessages != nil {
+		u.DeletedBusinessMessage = u.DeletedBusinessMessages
+		return
+	}
+	if u.DeletedBusinessMessage != nil {
+		u.DeletedBusinessMessages = u.DeletedBusinessMessage
+	}
+}
+
+// UnmarshalJSON keeps the deprecated DeletedBusinessMessage alias in sync.
+func (u *Update) UnmarshalJSON(data []byte) error {
+	type alias Update
+	var aux alias
+	if err := json.Unmarshal(data, &aux); err != nil {
+		return err
+	}
+	*u = Update(aux)
+	u.syncDeletedBusinessMessages()
+	return nil
+}
+
+// MarshalJSON emits the canonical deleted_business_messages field.
+func (u Update) MarshalJSON() ([]byte, error) {
+	u.syncDeletedBusinessMessages()
+	type alias Update
+	return json.Marshal(alias(u))
+}
+
+// InlineQuery represents an incoming inline query.
+// See https://core.telegram.org/bots/api#inlinequery
+type InlineQuery struct {
+	ID       string    `json:"id"`
+	From     User      `json:"from"`
+	Query    string    `json:"query"`
+	Offset   string    `json:"offset"`
+	ChatType *ChatType `json:"chat_type,omitempty"`
+	Location *Location `json:"location,omitempty"`
+}
+
+// ChosenInlineResult represents a result of an inline query that was chosen by the user.
+// See https://core.telegram.org/bots/api#choseninlineresult
+type ChosenInlineResult struct {
+	ResultID        string    `json:"result_id"`
+	From            User      `json:"from"`
+	Location        *Location `json:"location,omitempty"`
+	InlineMessageID string    `json:"inline_message_id"`
+	Query           string    `json:"query"`
+}
+
+// ShippingQuery represents an incoming shipping query.
+// See https://core.telegram.org/bots/api#shippingquery
+type ShippingQuery struct {
+	ID              string          `json:"id"`
+	From            User            `json:"from"`
+	InvoicePayload  string          `json:"invoice_payload"`
+	ShippingAddress ShippingAddress `json:"shipping_address"`
+}
+
+// ShippingAddress represents a shipping address.
+// See https://core.telegram.org/bots/api#shippingaddress
+type ShippingAddress struct {
+	CountryCode string `json:"country_code"`
+	State       string `json:"state"`
+	City        string `json:"city"`
+	StreetLine1 string `json:"street_line1"`
+	StreetLine2 string `json:"street_line2"`
+	PostCode    string `json:"post_code"`
+}
+
+// OrderInfo represents information about an order.
+// See https://core.telegram.org/bots/api#orderinfo
+type OrderInfo struct {
+	Name            string          `json:"name"`
+	PhoneNumber     string          `json:"phone_number"`
+	Email           string          `json:"email"`
+	ShippingAddress ShippingAddress `json:"shipping_address"`
+}
+
+// PreCheckoutQuery represents an incoming pre-checkout query.
+// See https://core.telegram.org/bots/api#precheckoutquery
+type PreCheckoutQuery struct {
+	ID               string     `json:"id"`
+	From             User       `json:"from"`
+	Currency         string     `json:"currency"`
+	TotalAmount      int        `json:"total_amount"`
+	InvoicePayload   string     `json:"invoice_payload"`
+	ShippingOptionID string     `json:"shipping_option_id"`
+	OrderInfo        *OrderInfo `json:"order_info,omitempty"`
+}
+
+// PaidMediaPurchased represents a purchased paid media.
+// See https://core.telegram.org/bots/api#paidmediapurchased
+type PaidMediaPurchased struct {
+	From             User   `json:"from"`
+	PaidMediaPayload string `json:"paid_media_payload"`
+}
+
+// File represents a file ready to be downloaded.
+// See https://core.telegram.org/bots/api#file
+type File struct {
+	FileId       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	FileSize     int64  `json:"file_size,omitempty"`
+	FilePath     string `json:"file_path,omitempty"`
+}
+
+// Audio represents an audio file to be treated as music by the Telegram clients.
+// See https://core.telegram.org/bots/api#audio
+type Audio struct {
+	FileID       string `json:"file_id"`
+	FileUniqueID string `json:"file_unique_id"`
+	Duration     int    `json:"duration"`
+
+	Performer string     `json:"performer,omitempty"`
+	Title     string     `json:"title,omitempty"`
+	FileName  string     `json:"file_name,omitempty"`
+	MimeType  string     `json:"mime_type,omitempty"`
+	FileSize  int64      `json:"file_size,omitempty"`
+	Thumbnail *PhotoSize `json:"thumbnail,omitempty"`
+}
+
+// PollOption contains information about one answer option in a poll.
+// See https://core.telegram.org/bots/api#polloption
+type PollOption struct {
+	Text         string          `json:"text"`
+	TextEntities []MessageEntity `json:"text_entities"`
+	VoterCount   int             `json:"voter_count"`
+}
+
+// Poll contains information about a poll.
+// See https://core.telegram.org/bots/api#poll
+type Poll struct {
+	ID               string          `json:"id"`
+	Question         string          `json:"question"`
+	QuestionEntities []MessageEntity `json:"question_entities"`
+	Options          []PollOption    `json:"options"`
+	TotalVoterCount  int             `json:"total_voter_count"`
+	IsClosed         bool            `json:"is_closed"`
+	IsAnonymous      bool            `json:"is_anonymous"`
+	Type             PollType        `json:"type"`
+
+	AllowsMultipleAnswers bool            `json:"allows_multiple_answers"`
+	CorrectOptionID       *int            `json:"correct_option_id,omitempty"`
+	Explanation           *string         `json:"explanation,omitempty"`
+	ExplanationEntities   []MessageEntity `json:"explanation_entities,omitempty"`
+	OpenPeriod            int             `json:"open_period,omitempty"`
+	CloseDate             int             `json:"close_date,omitempty"`
+}
+
+// PollAnswer represents an answer of a user in a poll.
+// See https://core.telegram.org/bots/api#pollanswer
+type PollAnswer struct {
+	PollID    string `json:"poll_id"`
+	VoterChat Chat   `json:"voter_chat"`
+	User      User   `json:"user"`
+	OptionIDS []int  `json:"option_ids"`
+}
+
+// ChatMemberUpdated represents changes in the status of a chat member.
+// See https://core.telegram.org/bots/api#chatmemberupdated
+type ChatMemberUpdated struct {
+	Chat                    Chat            `json:"chat"`
+	From                    User            `json:"from"`
+	Date                    int64           `json:"date"`
+	OldChatMember           ChatMember      `json:"old_chat_member"`
+	NewChatMember           ChatMember      `json:"new_chat_member"`
+	InviteLink              *ChatInviteLink `json:"invite_link,omitempty"`
+	ViaJoinRequest          *bool           `json:"via_join_request,omitempty"`
+	ViaChatFolderInviteLink *bool           `json:"via_chat_folder_invite_link,omitempty"`
+}
+
+// ChatJoinRequest represents a join request sent to a chat.
+// See https://core.telegram.org/bots/api#chatjoinrequest
+type ChatJoinRequest struct {
+	Chat       Chat            `json:"chat"`
+	From       User            `json:"from"`
+	UserChatID int64           `json:"user_chat_id"`
+	Date       int64           `json:"date"`
+	Bio        *string         `json:"bio,omitempty"`
+	InviteLink *ChatInviteLink `json:"invite_link,omitempty"`
+}
+
+// Location represents a point on the map.
+// See https://core.telegram.org/bots/api#location
+type Location struct {
+	Latitude             float64 `json:"latitude"`
+	Longitude            float64 `json:"longitude"`
+	HorizontalAccuracy   float64 `json:"horizontal_accuracy"`
+	LivePeriod           int     `json:"live_period"`
+	Heading              int     `json:"heading"`
+	ProximityAlertRadius int     `json:"proximity_alert_radius"`
+}
+
+// LocationAddress represents a human-readable address of a location.
+type LocationAddress struct {
+	CountryCode string  `json:"country_code"`
+	State       *string `json:"state,omitempty"`
+	City        *string `json:"city,omitempty"`
+	Street      *string `json:"street,omitempty"`
+}
+
+// Venue represents a venue.
+// See https://core.telegram.org/bots/api#venue
+type Venue struct {
+	Location        Location `json:"location"`
+	Title           string   `json:"title"`
+	Address         string   `json:"address"`
+	FoursquareID    string   `json:"foursquare_id,omitempty"`
+	FoursquareType  string   `json:"foursquare_type,omitempty"`
+	GooglePlaceID   string   `json:"google_place_id,omitempty"`
+	GooglePlaceType string   `json:"google_place_type,omitempty"`
+}
+
+// WebAppInfo contains information about a Web App.
+// See https://core.telegram.org/bots/api#webappinfo
+type WebAppInfo struct {
+	URL string `json:"url"`
+}
+
+// StarAmount represents an amount of Telegram Stars.
+type StarAmount struct {
+	Amount         int `json:"amount"`
+	NanostarAmount int `json:"nanostar_amount"`
+}
+
+// Story represents a story.
+type Story struct {
+	Chat Chat `json:"chat"`
+	ID   int  `json:"id"`
+}
+
+// AcceptedGiftTypes represents the types of gifts accepted by a user or chat.
+type AcceptedGiftTypes struct {
+	UnlimitedGifts      bool `json:"unlimited_gifts"`
+	LimitedGifts        bool `json:"limited_gifts"`
+	UniqueGifts         bool `json:"unique_gifts"`
+	PremiumSubscription bool `json:"premium_subscription"`
+	GiftsFromChannels   bool `json:"gifts_from_channels"`
+}
+
+// UniqueGiftColors represents color information for a unique gift.
+type UniqueGiftColors struct {
+	ModelCustomEmojiID    string `json:"model_custom_emoji_id"`
+	SymbolCustomEmojiID   string `json:"symbol_custom_emoji_id"`
+	LightThemeMainColor   int    `json:"light_theme_main_color"`
+	LightThemeOtherColors []int  `json:"light_theme_other_colors"`
+	DarkThemeMainColor    int    `json:"dark_theme_main_color"`
+	DarkThemeOtherColors  []int  `json:"dark_theme_other_colors"`
+}
+
+// GiftBackground represents the background of a gift.
+type GiftBackground struct {
+	CenterColor int `json:"center_color"`
+	EdgeColor   int `json:"edge_color"`
+	TextColor   int `json:"text_color"`
+}
+
+// Gift represents a gift that can be sent.
+type Gift struct {
+	ID                     string         `json:"id"`
+	Sticker                Sticker        `json:"sticker"`
+	StarCount              int            `json:"star_count"`
+	UpdateStarCount        *int           `json:"update_star_count,omitempty"`
+	IsPremium              *bool          `json:"is_premium,omitempty"`
+	HasColors              *bool          `json:"has_colors,omitempty"`
+	TotalCount             *int           `json:"total_count,omitempty"`
+	RemainingCount         *int           `json:"remaining_count,omitempty"`
+	PersonalTotalCount     *int           `json:"personal_total_count,omitempty"`
+	PersonalRemainingCount *int           `json:"personal_remaining_count,omitempty"`
+	Background             GiftBackground `json:"background,omitempty"`
+	UniqueGiftVariantColor *int           `json:"unique_gift_variant_color,omitempty"`
+	PublisherChat          *Chat          `json:"publisher_chat,omitempty"`
+}
+
+// Gifts represents a list of gifts.
+type Gifts struct {
+	Gifts []Gift `json:"gifts"`
+}
+
+// OwnedGiftType represents the type of an owned gift.
+type OwnedGiftType string
+
+const (
+	OwnedGiftRegularType OwnedGiftType = "regular"
+	OwnedGiftUniqueType  OwnedGiftType = "unique"
+)
+
+// OwnedGift represents a gift owned by a user or chat.
+type OwnedGift struct {
+	Type        OwnedGiftType `json:"type"`
+	OwnerGiftID *string       `json:"owner_gift_id,omitempty"`
+	SendDate    *int          `json:"send_date,omitempty"`
+	IsSaved     *bool         `json:"is_saved,omitempty"`
+
+	// Fields specific to "regular" type
+	Gift                    Gift            `json:"gift"`
+	SenderUser              User            `json:"sender_user,omitempty"`
+	Text                    string          `json:"text,omitempty"`
+	Entities                []MessageEntity `json:"entities,omitempty"`
+	IsPrivate               *bool           `json:"is_private,omitempty"`
+	CanBeUpgraded           *bool           `json:"can_be_upgraded,omitempty"`
+	WasRefunded             *bool           `json:"was_refunded,omitempty"`
+	ConvertStarCount        *int            `json:"convert_star_count,omitempty"`
+	PrepaidUpgradeStarCount *int            `json:"prepaid_upgrade_star_count,omitempty"`
+	IsUpgradeSeparate       *bool           `json:"is_upgrade_separate,omitempty"`
+	UniqueGiftNumber        *int            `json:"unique_gift_number,omitempty"`
+
+	// Fields specific to "unique" type
+	CanBeTransferred  *bool `json:"can_be_transferred,omitempty"`
+	TransferStarCount *int  `json:"transfer_star_count,omitempty"`
+	NextTransferDate  *int  `json:"next_transfer_date,omitempty"`
+}
+
+// OwnedGifts represents a list of owned gifts with pagination.
+type OwnedGifts struct {
+	TotalCount int         `json:"total_count"`
+	Gifts      []OwnedGift `json:"gifts"`
+	NextOffset string      `json:"next_offset"`
+}

tgapi/types_test.go

@@ -0,0 +1,69 @@
+package tgapi
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestUpdateDeletedBusinessMessagesUnmarshalSetsAlias(t *testing.T) {
+	var update Update
+	err := json.Unmarshal([]byte(`{
+		"update_id": 1,
+		"deleted_business_messages": {
+			"business_connection_id": "conn",
+			"chat": {"id": 42, "type": "private"},
+			"message_ids": [3, 5]
+		}
+	}`), &update)
+	if err != nil {
+		t.Fatalf("Unmarshal returned error: %v", err)
+	}
+
+	if update.DeletedBusinessMessages == nil {
+		t.Fatal("expected DeletedBusinessMessages to be populated")
+	}
+	if update.DeletedBusinessMessage == nil {
+		t.Fatal("expected deprecated DeletedBusinessMessage alias to be populated")
+	}
+	if update.DeletedBusinessMessages != update.DeletedBusinessMessage {
+		t.Fatal("expected deleted business message fields to share the same payload")
+	}
+	if got := update.DeletedBusinessMessages.MessageIDs; len(got) != 2 || got[0] != 3 || got[1] != 5 {
+		t.Fatalf("unexpected message ids: %v", got)
+	}
+}
+
+func TestUpdateMarshalUsesCanonicalDeletedBusinessMessagesField(t *testing.T) {
+	update := Update{
+		UpdateID: 1,
+		DeletedBusinessMessage: &BusinessMessagesDeleted{
+			BusinessConnectionID: "conn",
+			Chat:                 Chat{ID: 42, Type: string(ChatTypePrivate)},
+			MessageIDs:           []int{7},
+		},
+	}
+
+	data, err := json.Marshal(update)
+	if err != nil {
+		t.Fatalf("Marshal returned error: %v", err)
+	}
+
+	got := string(data)
+	if !strings.Contains(got, `"deleted_business_messages"`) {
+		t.Fatalf("expected canonical deleted_business_messages field, got %s", got)
+	}
+	if strings.Contains(got, `"deleted_business_message"`) {
+		t.Fatalf("unexpected singular deleted_business_message field, got %s", got)
+	}
+}
+
+func TestUpdateShippingQueryIsNilWhenAbsent(t *testing.T) {
+	var update Update
+	if err := json.Unmarshal([]byte(`{"update_id":1}`), &update); err != nil {
+		t.Fatalf("Unmarshal returned error: %v", err)
+	}
+	if update.ShippingQuery != nil {
+		t.Fatalf("expected ShippingQuery to be nil, got %+v", update.ShippingQuery)
+	}
+}

tgapi/uploader_api.go

@@ -0,0 +1,256 @@
+package tgapi
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"mime/multipart"
+	"net/http"
+	"path/filepath"
+	"time"
+
+	"git.nix13.pw/scuroneko/laniakea/utils"
+	"git.nix13.pw/scuroneko/slog"
+)
+
+const (
+	// UploaderPhotoType is the multipart field name for photo uploads.
+	UploaderPhotoType UploaderFileType = "photo"
+	// UploaderVideoType is the multipart field name for video uploads.
+	UploaderVideoType UploaderFileType = "video"
+	// UploaderAudioType is the multipart field name for audio uploads.
+	UploaderAudioType UploaderFileType = "audio"
+	// UploaderDocumentType is the multipart field name for document uploads.
+	UploaderDocumentType UploaderFileType = "document"
+	// UploaderVoiceType is the multipart field name for voice uploads.
+	UploaderVoiceType UploaderFileType = "voice"
+	// UploaderVideoNoteType is the multipart field name for video-note uploads.
+	UploaderVideoNoteType UploaderFileType = "video_note"
+	// UploaderThumbnailType is the multipart field name for thumbnail uploads.
+	UploaderThumbnailType UploaderFileType = "thumbnail"
+	// UploaderStickerType is the multipart field name for sticker uploads.
+	UploaderStickerType UploaderFileType = "sticker"
+)
+
+// UploaderFileType represents the Telegram form field name for a file upload.
+type UploaderFileType string
+
+// UploaderFile holds the data and metadata for a single file to be uploaded.
+type UploaderFile struct {
+	filename string
+	data     []byte
+	field    UploaderFileType
+}
+
+// NewUploaderFile creates a new UploaderFile, auto-detecting the field type from the file extension.
+// If detection is incorrect, use SetType to override.
+func NewUploaderFile(name string, data []byte) UploaderFile {
+	t := uploaderTypeByExt(name)
+	return UploaderFile{filename: name, data: data, field: t}
+}
+
+// SetType overrides the auto-detected upload field type.
+// For example, use it when a voice file is detected as audio.
+func (f UploaderFile) SetType(t UploaderFileType) UploaderFile {
+	f.field = t
+	return f
+}
+
+// Uploader is a Telegram Bot API client specialized for multipart file uploads.
+//
+// Use Uploader methods when you need to upload binary files directly
+// (InputFile/multipart). For JSON-only calls (file_id, URL, plain params), use API.
+type Uploader struct {
+	api    *API
+	logger *slog.Logger
+}
+
+// NewUploader creates a multipart uploader bound to an API client.
+func NewUploader(api *API) *Uploader {
+	logger := slog.CreateLogger().Level(utils.GetLoggerLevel()).Prefix("UPLOADER")
+	logger.AddWriter(logger.CreateJsonStdoutWriter())
+	return &Uploader{api, logger}
+}
+
+// Close flushes and closes uploader logger resources.
+// See https://core.telegram.org/bots/api
+func (u *Uploader) Close() error { return u.logger.Close() }
+
+// GetLogger returns uploader logger instance.
+// See https://core.telegram.org/bots/api
+func (u *Uploader) GetLogger() *slog.Logger { return u.logger }
+
+// UploaderRequest is a multipart file upload request to the Telegram API.
+// Use NewUploaderRequest or NewUploaderRequestWithChatID to construct one.
+type UploaderRequest[R, P any] struct {
+	method string
+	files  []UploaderFile
+	params P
+	chatId int64
+}
+
+// NewUploaderRequest creates a new multipart upload request with no associated chat ID.
+func NewUploaderRequest[R, P any](method string, params P, files ...UploaderFile) UploaderRequest[R, P] {
+	return UploaderRequest[R, P]{method: method, files: files, params: params, chatId: 0}
+}
+
+// NewUploaderRequestWithChatID creates a new multipart upload request with an associated chat ID.
+// The chat ID is used for per-chat rate limiting.
+func NewUploaderRequestWithChatID[R, P any](method string, params P, chatId int64, files ...UploaderFile) UploaderRequest[R, P] {
+	return UploaderRequest[R, P]{method: method, files: files, params: params, chatId: chatId}
+}
+func (r UploaderRequest[R, P]) doRequest(ctx context.Context, up *Uploader) (R, error) {
+	var zero R
+
+	methodPrefix := ""
+	if up.api.useTestServer {
+		methodPrefix = "/test"
+	}
+	url := fmt.Sprintf("%s/bot%s%s/%s", up.api.apiUrl, up.api.token, methodPrefix, r.method)
+
+	for {
+		if up.api.Limiter != nil {
+			if err := up.api.Limiter.Check(ctx, up.api.dropOverflowLimit, r.chatId); err != nil {
+				return zero, err
+			}
+		}
+
+		buf, contentType, err := prepareMultipart(r.files, r.params)
+		if err != nil {
+			return zero, err
+		}
+		req, err := http.NewRequestWithContext(ctx, "POST", url, buf)
+		if err != nil {
+			return zero, err
+		}
+		req.Header.Set("Content-Type", contentType)
+		req.Header.Set("Accept", "application/json")
+		req.Header.Set("User-Agent", fmt.Sprintf("Laniakea/%s", utils.VersionString))
+		req.ContentLength = int64(buf.Len())
+
+		up.logger.Debugln("UPLOADER REQ", r.method)
+		resp, err := up.api.client.Do(req)
+		if err != nil {
+			return zero, err
+		}
+
+		body, err := readBody(resp.Body)
+		_ = resp.Body.Close()
+		if err != nil {
+			return zero, err
+		}
+		up.logger.Debugln("UPLOADER RES", r.method, string(body))
+
+		response, err := parseBody[R](body)
+		if err != nil {
+			return zero, err
+		}
+
+		if !response.Ok {
+			if response.ErrorCode == 429 && response.Parameters != nil && response.Parameters.RetryAfter != nil {
+				after := *response.Parameters.RetryAfter
+				up.logger.Warnf("Rate limited, retry after %d seconds (chat: %d)", after, r.chatId)
+				if up.api.Limiter != nil {
+					if r.chatId > 0 {
+						up.api.Limiter.SetChatLock(r.chatId, after)
+					} else {
+						up.api.Limiter.SetGlobalLock(after)
+					}
+				}
+
+				select {
+				case <-ctx.Done():
+					return zero, ctx.Err()
+				case <-time.After(time.Duration(after) * time.Second):
+					continue // Повторяем запрос
+				}
+			}
+			return zero, fmt.Errorf("[%d] %s", response.ErrorCode, response.Description)
+		}
+		return response.Result, nil
+	}
+}
+
+// DoWithContext executes the upload request asynchronously via the worker pool.
+// Returns the result or error. Respects context cancellation.
+func (r UploaderRequest[R, P]) DoWithContext(ctx context.Context, up *Uploader) (R, error) {
+	var zero R
+
+	result, err := up.api.pool.submit(ctx, func(ctx context.Context) (any, error) {
+		return r.doRequest(ctx, up)
+	})
+	if err != nil {
+		return zero, err
+	}
+
+	select {
+	case <-ctx.Done():
+		return zero, ctx.Err()
+	case res := <-result:
+		if res.err != nil {
+			return zero, res.err
+		}
+		if val, ok := res.value.(R); ok {
+			return val, nil
+		}
+		return zero, ErrPoolUnexpected
+	}
+}
+
+// Do executes the upload request synchronously with a background context.
+// Use only for simple, non-critical uploads.
+func (r UploaderRequest[R, P]) Do(up *Uploader) (R, error) {
+	return r.DoWithContext(context.Background(), up)
+}
+
+// prepareMultipart builds a multipart form body from the given files and params.
+// Params are encoded via utils.Encode. The writer boundary is finalized before returning.
+func prepareMultipart[P any](files []UploaderFile, params P) (*bytes.Buffer, string, error) {
+	buf := bytes.NewBuffer(nil)
+	w := multipart.NewWriter(buf)
+
+	for _, file := range files {
+		fw, err := w.CreateFormFile(string(file.field), file.filename)
+		if err != nil {
+			_ = w.Close() // Закрываем, чтобы не было утечки
+			return nil, "", err
+		}
+
+		_, err = fw.Write(file.data)
+		if err != nil {
+			_ = w.Close()
+			return nil, "", err
+		}
+	}
+
+	err := utils.Encode(w, params) // Предполагается, что это записывает в w
+	if err != nil {
+		_ = w.Close()
+		return nil, "", err
+	}
+
+	err = w.Close() // ✅ ОБЯЗАТЕЛЬНО вызвать в конце — иначе запрос битый!
+	if err != nil {
+		return nil, "", err
+	}
+
+	return buf, w.FormDataContentType(), nil
+}
+
+// uploaderTypeByExt infers the Telegram upload field name from a file extension.
+// Falls back to UploaderDocumentType for unrecognized extensions.
+func uploaderTypeByExt(filename string) UploaderFileType {
+	ext := filepath.Ext(filename)
+	switch ext {
+	case ".jpg", ".jpeg", ".png", ".webp", ".bmp":
+		return UploaderPhotoType
+	case ".mp4":
+		return UploaderVideoType
+	case ".mp3", ".m4a":
+		return UploaderAudioType
+	case ".ogg":
+		return UploaderVoiceType
+	default:
+		return UploaderDocumentType
+	}
+}

tgapi/uploader_api_test.go

@@ -0,0 +1,138 @@
+package tgapi
+
+import (
+	"fmt"
+	"io"
+	"mime"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+func TestUploaderEncodesJSONFieldsAndLeavesAcceptEncodingToHTTPTransport(t *testing.T) {
+	var (
+		gotPath           string
+		gotAcceptEncoding string
+		gotFields         map[string]string
+		gotFileName       string
+		gotFileData       []byte
+		roundTripErr      error
+	)
+
+	client := &http.Client{
+		Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+			gotPath = req.URL.Path
+			gotAcceptEncoding = req.Header.Get("Accept-Encoding")
+
+			gotFields, gotFileName, gotFileData, roundTripErr = readMultipartRequest(req)
+			if roundTripErr != nil {
+				roundTripErr = fmt.Errorf("readMultipartRequest: %w", roundTripErr)
+			}
+
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Header:     http.Header{"Content-Type": []string{"application/json"}},
+				Body:       io.NopCloser(strings.NewReader(`{"ok":true,"result":{"message_id":5,"date":1}}`)),
+			}, nil
+		}),
+	}
+
+	api := NewAPI(
+		NewAPIOpts("token").
+			SetAPIUrl("https://example.test").
+			SetHTTPClient(client),
+	)
+	defer func() {
+		if err := api.CloseApi(); err != nil {
+			t.Fatalf("CloseApi returned error: %v", err)
+		}
+	}()
+
+	uploader := NewUploader(api)
+	defer func() {
+		if err := uploader.Close(); err != nil {
+			t.Fatalf("Close returned error: %v", err)
+		}
+	}()
+
+	msg, err := uploader.SendPhoto(
+		UploadPhotoP{
+			ChatID: 42,
+			CaptionEntities: []MessageEntity{{
+				Type:   MessageEntityBold,
+				Offset: 0,
+				Length: 4,
+			}},
+			ReplyMarkup: &ReplyMarkup{
+				InlineKeyboard: [][]InlineKeyboardButton{{
+					{Text: "A", CallbackData: "b"},
+				}},
+			},
+		},
+		NewUploaderFile("photo.jpg", []byte("img")),
+	)
+	if err != nil {
+		t.Fatalf("SendPhoto returned error: %v", err)
+	}
+	if msg.MessageID != 5 {
+		t.Fatalf("unexpected message id: %d", msg.MessageID)
+	}
+	if roundTripErr != nil {
+		t.Fatalf("multipart parse failed: %v", roundTripErr)
+	}
+	if gotPath != "/bottoken/sendPhoto" {
+		t.Fatalf("unexpected request path: %s", gotPath)
+	}
+	if gotAcceptEncoding != "" {
+		t.Fatalf("expected empty Accept-Encoding header, got %q", gotAcceptEncoding)
+	}
+	if got := gotFields["chat_id"]; got != "42" {
+		t.Fatalf("chat_id mismatch: %q", got)
+	}
+	if got := gotFields["caption_entities"]; got != `[{"type":"bold","offset":0,"length":4}]` {
+		t.Fatalf("caption_entities mismatch: %q", got)
+	}
+	if got := gotFields["reply_markup"]; got != `{"inline_keyboard":[[{"text":"A","callback_data":"b"}]]}` {
+		t.Fatalf("reply_markup mismatch: %q", got)
+	}
+	if gotFileName != "photo.jpg" {
+		t.Fatalf("unexpected file name: %q", gotFileName)
+	}
+	if string(gotFileData) != "img" {
+		t.Fatalf("unexpected file content: %q", string(gotFileData))
+	}
+}
+
+func readMultipartRequest(req *http.Request) (map[string]string, string, []byte, error) {
+	_, params, err := mime.ParseMediaType(req.Header.Get("Content-Type"))
+	if err != nil {
+		return nil, "", nil, err
+	}
+	reader := multipart.NewReader(req.Body, params["boundary"])
+
+	fields := make(map[string]string)
+	var fileName string
+	var fileData []byte
+	for {
+		part, err := reader.NextPart()
+		if err == io.EOF {
+			return fields, fileName, fileData, nil
+		}
+		if err != nil {
+			return nil, "", nil, err
+		}
+
+		data, err := io.ReadAll(part)
+		if err != nil {
+			return nil, "", nil, err
+		}
+
+		if part.FileName() != "" {
+			fileName = part.FileName()
+			fileData = data
+			continue
+		}
+		fields[part.FormName()] = string(data)
+	}
+}

tgapi/uploader_methods.go

@@ -0,0 +1,246 @@
+package tgapi
+
+// UploadPhotoP holds parameters for uploading a photo using the Uploader.
+// See https://core.telegram.org/bots/api#sendphoto
+type UploadPhotoP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	ShowCaptionAboveMedia bool   `json:"show_caption_above_media,omitempty"`
+	HasSpoiler            bool   `json:"has_spoiler,omitempty"`
+	DisableNotification   bool   `json:"disable_notification,omitempty"`
+	ProtectContent        bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendPhoto uploads a photo via multipart and sends it as a message.
+// file is the photo file to upload.
+// See https://core.telegram.org/bots/api#sendphoto
+func (u *Uploader) SendPhoto(params UploadPhotoP, file UploaderFile) (Message, error) {
+	req := NewUploaderRequestWithChatID[Message]("sendPhoto", params, params.ChatID, file)
+	return req.Do(u)
+}
+
+// UploadAudioP holds parameters for uploading an audio file using the Uploader.
+// See https://core.telegram.org/bots/api#sendaudio
+type UploadAudioP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	Duration  int    `json:"duration,omitempty"`
+	Performer string `json:"performer,omitempty"`
+	Title     string `json:"title,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendAudio uploads an audio file via multipart and sends it as a message.
+// files are the audio file(s) to upload (typically one file).
+// See https://core.telegram.org/bots/api#sendaudio
+func (u *Uploader) SendAudio(params UploadAudioP, files ...UploaderFile) (Message, error) {
+	req := NewUploaderRequestWithChatID[Message]("sendAudio", params, params.ChatID, files...)
+	return req.Do(u)
+}
+
+// UploadDocumentP holds parameters for uploading a document using the Uploader.
+// See https://core.telegram.org/bots/api#senddocument
+type UploadDocumentP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	DisableContentTypeDetection bool   `json:"disable_content_type_detection,omitempty"`
+	DisableNotification         bool   `json:"disable_notification,omitempty"`
+	ProtectContent              bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast          bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID             string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendDocument uploads a document via multipart and sends it as a message.
+// files are the document file(s) to upload (typically one file).
+// See https://core.telegram.org/bots/api#senddocument
+func (u *Uploader) SendDocument(params UploadDocumentP, files ...UploaderFile) (Message, error) {
+	req := NewUploaderRequestWithChatID[Message]("sendDocument", params, params.ChatID, files...)
+	return req.Do(u)
+}
+
+// UploadVideoP holds parameters for uploading a video using the Uploader.
+// See https://core.telegram.org/bots/api#sendvideo
+type UploadVideoP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Duration int `json:"duration,omitempty"`
+	Width    int `json:"width,omitempty"`
+	Height   int `json:"height,omitempty"`
+
+	StartTimestamp  int64           `json:"start_timestamp,omitempty"`
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	ShowCaptionAboveMedia bool   `json:"show_caption_above_media,omitempty"`
+	HasSpoiler            bool   `json:"has_spoiler,omitempty"`
+	SupportsStreaming     bool   `json:"supports_streaming,omitempty"`
+	DisableNotification   bool   `json:"disable_notification,omitempty"`
+	ProtectContent        bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendVideo uploads a video via multipart and sends it as a message.
+// files are the video file(s) to upload (typically one file).
+// See https://core.telegram.org/bots/api#sendvideo
+func (u *Uploader) SendVideo(params UploadVideoP, files ...UploaderFile) (Message, error) {
+	req := NewUploaderRequestWithChatID[Message]("sendVideo", params, params.ChatID, files...)
+	return req.Do(u)
+}
+
+// UploadAnimationP holds parameters for uploading an animation using the Uploader.
+// See https://core.telegram.org/bots/api#sendanimation
+type UploadAnimationP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Duration int `json:"duration,omitempty"`
+	Width    int `json:"width,omitempty"`
+	Height   int `json:"height,omitempty"`
+
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+
+	ShowCaptionAboveMedia bool   `json:"show_caption_above_media,omitempty"`
+	HasSpoiler            bool   `json:"has_spoiler,omitempty"`
+	DisableNotification   bool   `json:"disable_notification,omitempty"`
+	ProtectContent        bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast    bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID       string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendAnimation uploads an animation via multipart and sends it as a message.
+// files are the animation file(s) to upload (typically one file).
+// See https://core.telegram.org/bots/api#sendanimation
+func (u *Uploader) SendAnimation(params UploadAnimationP, files ...UploaderFile) (Message, error) {
+	req := NewUploaderRequestWithChatID[Message]("sendAnimation", params, params.ChatID, files...)
+	return req.Do(u)
+}
+
+// UploadVoiceP holds parameters for uploading a voice note using the Uploader.
+// See https://core.telegram.org/bots/api#sendvoice
+type UploadVoiceP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Caption         string          `json:"caption,omitempty"`
+	ParseMode       ParseMode       `json:"parse_mode,omitempty"`
+	CaptionEntities []MessageEntity `json:"caption_entities,omitempty"`
+	Duration        int             `json:"duration,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendVoice uploads a voice note via multipart and sends it as a message.
+// files are the voice file(s) to upload (typically one file).
+// See https://core.telegram.org/bots/api#sendvoice
+func (u *Uploader) SendVoice(params UploadVoiceP, files ...UploaderFile) (Message, error) {
+	req := NewUploaderRequestWithChatID[Message]("sendVoice", params, params.ChatID, files...)
+	return req.Do(u)
+}
+
+// UploadVideoNoteP holds parameters for uploading a video note (rounded video) using the Uploader.
+// See https://core.telegram.org/bots/api#sendvideonote
+type UploadVideoNoteP struct {
+	BusinessConnectionID  string `json:"business_connection_id,omitempty"`
+	ChatID                int64  `json:"chat_id"`
+	MessageThreadID       int    `json:"message_thread_id,omitempty"`
+	DirectMessagesTopicID int    `json:"direct_messages_topic_id,omitempty"`
+
+	Duration int `json:"duration,omitempty"`
+	Length   int `json:"length,omitempty"`
+
+	DisableNotification bool   `json:"disable_notification,omitempty"`
+	ProtectContent      bool   `json:"protect_content,omitempty"`
+	AllowPaidBroadcast  bool   `json:"allow_paid_broadcast,omitempty"`
+	MessageEffectID     string `json:"message_effect_id,omitempty"`
+
+	SuggestedPostParameters *SuggestedPostParameters `json:"suggested_post_parameters,omitempty"`
+	ReplyParameters         *ReplyParameters         `json:"reply_parameters,omitempty"`
+	ReplyMarkup             *ReplyMarkup             `json:"reply_markup,omitempty"`
+}
+
+// SendVideoNote uploads a video note via multipart and sends it as a message.
+// files are the video note file(s) to upload (typically one file).
+// See https://core.telegram.org/bots/api#sendvideonote
+func (u *Uploader) SendVideoNote(params UploadVideoNoteP, files ...UploaderFile) (Message, error) {
+	req := NewUploaderRequestWithChatID[Message]("sendVideoNote", params, params.ChatID, files...)
+	return req.Do(u)
+}
+
+// UploadChatPhotoP holds parameters for uploading a chat photo using the Uploader.
+// See https://core.telegram.org/bots/api#setchatphoto
+type UploadChatPhotoP struct {
+	ChatID int64 `json:"chat_id"`
+}
+
+// SetChatPhoto uploads a new chat photo.
+// photo is the photo file to upload.
+// See https://core.telegram.org/bots/api#setchatphoto
+func (u *Uploader) SetChatPhoto(params UploadChatPhotoP, photo UploaderFile) (bool, error) {
+	req := NewUploaderRequestWithChatID[bool]("setChatPhoto", params, params.ChatID, photo)
+	return req.Do(u)
+}

tgapi/users_methods.go

@@ -0,0 +1,68 @@
+package tgapi
+
+// GetUserProfilePhotosP holds parameters for the GetUserProfilePhotos method.
+// See https://core.telegram.org/bots/api#getuserprofilephotos
+type GetUserProfilePhotosP struct {
+	UserID int64 `json:"user_id"`
+	Offset int   `json:"offset,omitempty"`
+	Limit  int   `json:"limit,omitempty"`
+}
+
+// GetUserProfilePhotos returns a list of profile pictures for a user.
+// See https://core.telegram.org/bots/api#getuserprofilephotos
+func (api *API) GetUserProfilePhotos(params GetUserProfilePhotosP) (UserProfilePhotos, error) {
+	req := NewRequest[UserProfilePhotos]("getUserProfilePhotos", params)
+	return req.Do(api)
+}
+
+// GetUserProfileAudiosP holds parameters for the GetUserProfileAudios method.
+// See https://core.telegram.org/bots/api#getuserprofileaudios
+type GetUserProfileAudiosP struct {
+	UserID int64 `json:"user_id"`
+	Offset int   `json:"offset,omitempty"`
+	Limit  int   `json:"limit,omitempty"`
+}
+
+// GetUserProfileAudios returns a list of profile audios for a user.
+// See https://core.telegram.org/bots/api#getuserprofileaudios
+func (api *API) GetUserProfileAudios(params GetUserProfileAudiosP) (UserProfileAudios, error) {
+	req := NewRequest[UserProfileAudios]("getUserProfileAudios", params)
+	return req.Do(api)
+}
+
+// SetUserEmojiStatusP holds parameters for the SetUserEmojiStatus method.
+// See https://core.telegram.org/bots/api#setuseremojistatus
+type SetUserEmojiStatusP struct {
+	UserID         int64  `json:"user_id"`
+	EmojiID        string `json:"emoji_status_custom_emoji_id,omitempty"`
+	ExpirationDate int    `json:"emoji_status_expiration_date,omitempty"`
+}
+
+// SetUserEmojiStatus sets a custom emoji status for a user.
+// Returns true on success.
+// See https://core.telegram.org/bots/api#setuseremojistatus
+func (api *API) SetUserEmojiStatus(params SetUserEmojiStatusP) (bool, error) {
+	req := NewRequest[bool]("setUserEmojiStatus", params)
+	return req.Do(api)
+}
+
+// GetUserGiftsP holds parameters for the GetUserGifts method.
+// See https://core.telegram.org/bots/api#getusergifts
+type GetUserGiftsP struct {
+	UserID                      int64  `json:"user_id"`
+	ExcludeUnlimited            bool   `json:"exclude_unlimited,omitempty"`
+	ExcludeLimitedUpgradable    bool   `json:"exclude_limited_upgradable,omitempty"`
+	ExcludeLimitedNonUpgradable bool   `json:"exclude_limited_non_upgradable,omitempty"`
+	ExcludeUnique               bool   `json:"exclude_unique,omitempty"`
+	ExcludeFromBlockchain       bool   `json:"exclude_from_blockchain,omitempty"`
+	SortByPrice                 bool   `json:"sort_by_price,omitempty"`
+	Offset                      string `json:"offset,omitempty"`
+	Limit                       int    `json:"limit,omitempty"`
+}
+
+// GetUserGifts returns gifts owned by a user.
+// See https://core.telegram.org/bots/api#getusergifts
+func (api *API) GetUserGifts(params GetUserGiftsP) (OwnedGifts, error) {
+	req := NewRequest[OwnedGifts]("getUserGifts", params)
+	return req.Do(api)
+}

tgapi/users_types.go

@@ -0,0 +1,52 @@
+package tgapi
+
+// User represents a Telegram user or bot.
+// See https://core.telegram.org/bots/api#user
+type User struct {
+	ID                        int64   `json:"id"`
+	IsBot                     bool    `json:"is_bot"`
+	FirstName                 string  `json:"first_name"`
+	LastName                  *string `json:"last_name,omitempty"`
+	Username                  *string `json:"username,omitempty"`
+	LanguageCode              *string `json:"language_code,omitempty"`
+	IsPremium                 *bool   `json:"is_premium,omitempty"`
+	AddedToAttachmentMenu     *bool   `json:"added_to_attachment_menu,omitempty"`
+	CanJoinGroups             *bool   `json:"can_join_groups,omitempty"`
+	CanReadAllGroupMessages   *bool   `json:"can_read_all_group_messages,omitempty"`
+	SupportsInlineQueries     *bool   `json:"supports_inline_queries,omitempty"`
+	CanConnectToBusiness      *bool   `json:"can_connect_to_business,omitempty"`
+	HasMainWebApp             *bool   `json:"has_main_web_app,omitempty"`
+	HasTopicsEnabled          *bool   `json:"has_topics_enabled,omitempty"`
+	AllowsUsersToCreateTopics *bool   `json:"allows_users_to_create_topics,omitempty"`
+}
+
+// UserProfilePhotos represents a user's profile photos.
+// See https://core.telegram.org/bots/api#userprofilephotos
+type UserProfilePhotos struct {
+	TotalCount int           `json:"total_count"`
+	Photos     [][]PhotoSize `json:"photos"`
+}
+
+// UserProfileAudios represents a user's profile audios.
+// See https://core.telegram.org/bots/api#userprofileaudios
+type UserProfileAudios struct {
+	TotalCount int     `json:"total_count"`
+	Audios     []Audio `json:"audios"`
+}
+
+// UserRating represents a user's rating with level progression.
+// See https://core.telegram.org/bots/api#userrating
+type UserRating struct {
+	Level              int `json:"level"`
+	Rating             int `json:"rating"`
+	CurrentLevelRating int `json:"current_level_rating"`
+	NextLevelRating    int `json:"next_level_rating"`
+}
+
+// Birthdate represents a user's birthdate.
+// See https://core.telegram.org/bots/api#birthdate
+type Birthdate struct {
+	Day   int `json:"day"`
+	Month int `json:"month"`
+	Year  int `json:"year"`
+}

utils.go

@@ -0,0 +1,63 @@
+package laniakea
+
+import (
+	"strings"
+
+	"git.nix13.pw/scuroneko/laniakea/utils"
+)
+
+// Ptr returns a pointer to v.
+func Ptr[T any](v T) *T { return &v }
+
+// Val returns dereferenced pointer value or def when p is nil.
+func Val[T any](p *T, def T) T {
+	if p != nil {
+		return *p
+	}
+	return def
+}
+
+// EscapeMarkdown escapes special characters for legacy Telegram Markdown.
+// Deprecated: Use EscapeMarkdownV2.
+func EscapeMarkdown(s string) string {
+	s = strings.ReplaceAll(s, "_", `\_`)
+	s = strings.ReplaceAll(s, "*", `\*`)
+	s = strings.ReplaceAll(s, "[", `\[`)
+	return strings.ReplaceAll(s, "`", "\\`")
+}
+
+// EscapeHTML escapes special characters for Telegram HTML parse mode.
+func EscapeHTML(s string) string {
+	s = strings.ReplaceAll(s, "&", "&")
+	s = strings.ReplaceAll(s, "<", "&lt;")
+	s = strings.ReplaceAll(s, ">", "&gt;")
+	return s
+}
+
+// EscapeMarkdownV2 escapes special characters for Telegram MarkdownV2.
+// https://core.telegram.org/bots/api#markdownv2-style
+func EscapeMarkdownV2(s string) string {
+	symbols := []string{"\\", "_", "*", "[", "]", "(", ")", "~", "`", ">", "#", "+", "-", "=", "|", "{", "}", ".", "!"}
+	for _, symbol := range symbols {
+		s = strings.ReplaceAll(s, symbol, "\\"+symbol)
+	}
+	return s
+}
+
+// EscapePunctuation escapes '.', '!' and '-' for MarkdownV2 fragments.
+func EscapePunctuation(s string) string {
+	symbols := []string{".", "!", "-"}
+	for _, symbol := range symbols {
+		s = strings.ReplaceAll(s, symbol, "\\"+symbol)
+	}
+	return s
+}
+
+// Version constants mirror values from the internal utils/version package.
+const (
+	VersionString = utils.VersionString
+	VersionMajor  = utils.VersionMajor
+	VersionMinor  = utils.VersionMinor
+	VersionPatch  = utils.VersionPatch
+	VersionBeta   = utils.VersionBeta
+)

utils/limiter.go

@@ -0,0 +1,243 @@
+package utils
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+
+	"golang.org/x/time/rate"
+)
+
+var ErrDropOverflow = errors.New("drop overflow limit")
+
+// RateLimiter implements per-chat and global rate limiting with optional blocking.
+// It supports two modes:
+//   - "drop" mode: immediately reject if limits are exceeded.
+//   - "wait" mode: block until capacity is available.
+type RateLimiter struct {
+	globalLockUntil time.Time     // global cooldown timestamp (set by API errors)
+	globalLimiter   *rate.Limiter // global token bucket (30 req/sec)
+	globalMu        sync.RWMutex  // protects globalLockUntil and globalLimiter
+
+	chatLocks    map[int64]time.Time     // per-chat cooldown timestamps
+	chatLimiters map[int64]*rate.Limiter // per-chat token buckets (1 req/sec)
+	chatMu       sync.RWMutex            // protects chatLocks and chatLimiters
+}
+
+// NewRateLimiter creates a new RateLimiter with default limits.
+// Global: 30 requests per second, burst 30.
+// Per-chat: 1 request per second, burst 1.
+func NewRateLimiter() *RateLimiter {
+	return &RateLimiter{
+		globalLimiter: rate.NewLimiter(30, 30),
+		chatLimiters:  make(map[int64]*rate.Limiter),
+		chatLocks:     make(map[int64]time.Time),
+	}
+}
+
+// SetGlobalRate overrides global request-per-second limit and burst.
+// If rps <= 0, current settings are kept.
+func (rl *RateLimiter) SetGlobalRate(rps int) {
+	if rps <= 0 {
+		return
+	}
+	rl.globalMu.Lock()
+	defer rl.globalMu.Unlock()
+	rl.globalLimiter = rate.NewLimiter(rate.Limit(rps), rps)
+}
+
+// SetGlobalLock sets a global cooldown period (e.g., after receiving 429 from Telegram).
+// If retryAfter <= 0, no lock is applied.
+func (rl *RateLimiter) SetGlobalLock(retryAfter int) {
+	if retryAfter <= 0 {
+		return
+	}
+	rl.globalMu.Lock()
+	defer rl.globalMu.Unlock()
+	rl.globalLockUntil = time.Now().Add(time.Duration(retryAfter) * time.Second)
+}
+
+// SetChatLock sets a cooldown for a specific chat (e.g., after 429 for that chat).
+// If retryAfter <= 0, no lock is applied.
+func (rl *RateLimiter) SetChatLock(chatID int64, retryAfter int) {
+	if retryAfter <= 0 {
+		return
+	}
+	rl.chatMu.Lock()
+	defer rl.chatMu.Unlock()
+	rl.chatLocks[chatID] = time.Now().Add(time.Duration(retryAfter) * time.Second)
+}
+
+// GlobalWait blocks until a global request can be made.
+// Waits for both global cooldown and token bucket availability.
+func (rl *RateLimiter) GlobalWait(ctx context.Context) error {
+	if err := rl.waitForGlobalUnlock(ctx); err != nil {
+		return err
+	}
+	limiter := rl.getGlobalLimiter()
+	if limiter == nil {
+		return nil
+	}
+	return limiter.Wait(ctx)
+}
+
+// Wait blocks until a request for the given chat can be made.
+// Waits for: chat cooldown → global cooldown → chat token bucket.
+// Note: Global limit is checked *before* chat limit to avoid overloading upstream.
+func (rl *RateLimiter) Wait(ctx context.Context, chatID int64) error {
+	if err := rl.waitForChatUnlock(ctx, chatID); err != nil {
+		return err
+	}
+	if err := rl.waitForGlobalUnlock(ctx); err != nil {
+		return err
+	}
+	limiter := rl.getGlobalLimiter()
+	if limiter != nil {
+		if err := limiter.Wait(ctx); err != nil {
+			return err
+		}
+	}
+	chatLimiter := rl.getChatLimiter(chatID)
+	return chatLimiter.Wait(ctx)
+}
+
+// getGlobalLimiter returns the global limiter safely under read lock.
+func (rl *RateLimiter) getGlobalLimiter() *rate.Limiter {
+	rl.globalMu.RLock()
+	defer rl.globalMu.RUnlock()
+	return rl.globalLimiter
+}
+
+// GlobalAllow checks if a global request can be made without blocking.
+// Returns false if either global cooldown is active or token bucket is exhausted.
+func (rl *RateLimiter) GlobalAllow() bool {
+	rl.globalMu.RLock()
+	until := rl.globalLockUntil
+	rl.globalMu.RUnlock()
+
+	if !until.IsZero() && time.Now().Before(until) {
+		return false
+	}
+	limiter := rl.getGlobalLimiter()
+	if limiter == nil {
+		return true
+	}
+	return limiter.Allow()
+}
+
+// Allow checks if a request for the given chat can be made without blocking.
+// Returns false if: global cooldown, chat cooldown, global limiter, or chat limiter denies.
+// Note: Global limiter is checked before chat limiter — upstream limits take priority.
+func (rl *RateLimiter) Allow(chatID int64) bool {
+	// Check global cooldown
+	rl.globalMu.RLock()
+	globalUntil := rl.globalLockUntil
+	rl.globalMu.RUnlock()
+	if !globalUntil.IsZero() && time.Now().Before(globalUntil) {
+		return false
+	}
+
+	// Check chat cooldown
+	rl.chatMu.RLock()
+	chatUntil, ok := rl.chatLocks[chatID]
+	rl.chatMu.RUnlock()
+	if ok && !chatUntil.IsZero() && time.Now().Before(chatUntil) {
+		return false
+	}
+
+	// Check global token bucket
+	limiter := rl.getGlobalLimiter()
+	if limiter != nil && !limiter.Allow() {
+		return false
+	}
+
+	// Check chat token bucket
+	chatLimiter := rl.getChatLimiter(chatID)
+	return chatLimiter.Allow()
+}
+
+// Check applies rate limiting based on configuration.
+// If dropOverflow is true:
+//   - Immediately returns ErrDropOverflow if either global or chat limit is exceeded.
+//
+// Else:
+//   - If chatID != 0: waits for chat-specific capacity (including global limit).
+//   - If chatID == 0: waits for global capacity only.
+//
+// chatID == 0 means no specific chat context (e.g., inline query, webhook without chat).
+func (rl *RateLimiter) Check(ctx context.Context, dropOverflow bool, chatID int64) error {
+	if dropOverflow {
+		if chatID != 0 {
+			if !rl.Allow(chatID) {
+
+				return ErrDropOverflow
+			}
+		} else {
+			if !rl.GlobalAllow() {
+				return ErrDropOverflow
+			}
+		}
+	} else if chatID != 0 {
+		if err := rl.Wait(ctx, chatID); err != nil {
+			return err
+		}
+	} else {
+		if err := rl.GlobalWait(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// waitForGlobalUnlock blocks until global cooldown expires or context is done.
+// Does not check token bucket — only cooldown.
+func (rl *RateLimiter) waitForGlobalUnlock(ctx context.Context) error {
+	rl.globalMu.RLock()
+	until := rl.globalLockUntil
+	rl.globalMu.RUnlock()
+
+	if until.IsZero() || time.Now().After(until) {
+		return nil
+	}
+
+	select {
+	case <-time.After(time.Until(until)):
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+// waitForChatUnlock blocks until the specified chat's cooldown expires or context is done.
+// Does not check token bucket — only cooldown.
+func (rl *RateLimiter) waitForChatUnlock(ctx context.Context, chatID int64) error {
+	rl.chatMu.RLock()
+	until, ok := rl.chatLocks[chatID]
+	rl.chatMu.RUnlock()
+
+	if !ok || until.IsZero() || time.Now().After(until) {
+		return nil
+	}
+
+	select {
+	case <-time.After(time.Until(until)):
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+// getChatLimiter returns the rate limiter for the given chat, creating it if needed.
+// Uses 1 request per second with burst of 1 — conservative for per-user limits.
+func (rl *RateLimiter) getChatLimiter(chatID int64) *rate.Limiter {
+	rl.chatMu.Lock()
+	defer rl.chatMu.Unlock()
+
+	if lim, ok := rl.chatLimiters[chatID]; ok {
+		return lim
+	}
+	lim := rate.NewLimiter(1, 1)
+	rl.chatLimiters[chatID] = lim
+	return lim
+}

utils/multipart.go

@@ -0,0 +1,115 @@
+package utils
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"reflect"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+// Encode writes struct fields into multipart form-data using json tags as field names.
+func Encode[T any](w *multipart.Writer, req T) error {
+	v := unwrapMultipartValue(reflect.ValueOf(req))
+	if !v.IsValid() || v.Kind() != reflect.Struct {
+		return fmt.Errorf("req must be a struct")
+	}
+
+	t := v.Type()
+	for i := 0; i < v.NumField(); i++ {
+		field := v.Field(i)
+		fieldType := t.Field(i)
+
+		jsonTag := fieldType.Tag.Get("json")
+		if jsonTag == "" {
+			jsonTag = fieldType.Name
+		}
+
+		parts := strings.Split(jsonTag, ",")
+		fieldName := parts[0]
+		if fieldName == "" {
+			fieldName = fieldType.Name
+		}
+		if fieldName == "-" {
+			continue
+		}
+
+		// Handle omitempty
+		isEmpty := field.IsZero()
+		if slices.Contains(parts, "omitempty") && isEmpty {
+			continue
+		}
+
+		if err := writeMultipartField(w, fieldName, fieldType.Tag.Get("filename"), field); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func unwrapMultipartValue(v reflect.Value) reflect.Value {
+	for v.IsValid() && (v.Kind() == reflect.Pointer || v.Kind() == reflect.Interface) {
+		if v.IsNil() {
+			return reflect.Value{}
+		}
+		v = v.Elem()
+	}
+	return v
+}
+
+func writeMultipartField(w *multipart.Writer, fieldName, filename string, field reflect.Value) error {
+	value := unwrapMultipartValue(field)
+	if !value.IsValid() {
+		return nil
+	}
+
+	switch value.Kind() {
+	case reflect.String:
+		return writeMultipartValue(w, fieldName, []byte(value.String()))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return writeMultipartValue(w, fieldName, []byte(strconv.FormatInt(value.Int(), 10)))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return writeMultipartValue(w, fieldName, []byte(strconv.FormatUint(value.Uint(), 10)))
+	case reflect.Float32:
+		return writeMultipartValue(w, fieldName, []byte(strconv.FormatFloat(value.Float(), 'f', -1, 32)))
+	case reflect.Float64:
+		return writeMultipartValue(w, fieldName, []byte(strconv.FormatFloat(value.Float(), 'f', -1, 64)))
+	case reflect.Bool:
+		return writeMultipartValue(w, fieldName, []byte(strconv.FormatBool(value.Bool())))
+	case reflect.Slice:
+		if value.Type().Elem().Kind() == reflect.Uint8 {
+			if filename == "" {
+				filename = fieldName
+			}
+			fw, err := w.CreateFormFile(fieldName, filename)
+			if err != nil {
+				return err
+			}
+			_, err = fw.Write(value.Bytes())
+			return err
+		}
+	}
+
+	// Telegram expects nested objects and arrays in multipart requests as JSON strings.
+	data, err := json.Marshal(value.Interface())
+	if err != nil {
+		return err
+	}
+	if string(data) == "null" {
+		return nil
+	}
+	return writeMultipartValue(w, fieldName, data)
+}
+
+func writeMultipartValue(w *multipart.Writer, fieldName string, value []byte) error {
+	fw, err := w.CreateFormField(fieldName)
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(fw, strings.NewReader(string(value)))
+	return err
+}

utils/multipart_test.go

@@ -0,0 +1,85 @@
+package utils_test
+
+import (
+	"bytes"
+	"io"
+	"mime/multipart"
+	"testing"
+
+	"git.nix13.pw/scuroneko/laniakea/tgapi"
+	"git.nix13.pw/scuroneko/laniakea/utils"
+)
+
+type multipartEncodeParams struct {
+	ChatID          int64                  `json:"chat_id"`
+	MessageThreadID *int                   `json:"message_thread_id,omitempty"`
+	ReplyMarkup     *tgapi.ReplyMarkup     `json:"reply_markup,omitempty"`
+	CaptionEntities []tgapi.MessageEntity  `json:"caption_entities,omitempty"`
+	ReplyParameters *tgapi.ReplyParameters `json:"reply_parameters,omitempty"`
+}
+
+func TestEncodeMultipartJSONFields(t *testing.T) {
+	threadID := 7
+	params := multipartEncodeParams{
+		ChatID:          42,
+		MessageThreadID: &threadID,
+		ReplyMarkup: &tgapi.ReplyMarkup{
+			InlineKeyboard: [][]tgapi.InlineKeyboardButton{{
+				{Text: "A", CallbackData: "b"},
+			}},
+		},
+		CaptionEntities: []tgapi.MessageEntity{{
+			Type:   tgapi.MessageEntityBold,
+			Offset: 0,
+			Length: 4,
+		}},
+	}
+
+	body := bytes.NewBuffer(nil)
+	writer := multipart.NewWriter(body)
+	if err := utils.Encode(writer, params); err != nil {
+		t.Fatalf("Encode returned error: %v", err)
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatalf("writer.Close returned error: %v", err)
+	}
+
+	got := readMultipartFields(t, body.Bytes(), writer.Boundary())
+	if got["chat_id"] != "42" {
+		t.Fatalf("chat_id mismatch: %q", got["chat_id"])
+	}
+	if got["message_thread_id"] != "7" {
+		t.Fatalf("message_thread_id mismatch: %q", got["message_thread_id"])
+	}
+	if got["reply_markup"] != `{"inline_keyboard":[[{"text":"A","callback_data":"b"}]]}` {
+		t.Fatalf("reply_markup mismatch: %q", got["reply_markup"])
+	}
+	if got["caption_entities"] != `[{"type":"bold","offset":0,"length":4}]` {
+		t.Fatalf("caption_entities mismatch: %q", got["caption_entities"])
+	}
+	if _, ok := got["reply_parameters"]; ok {
+		t.Fatalf("reply_parameters should be omitted when nil")
+	}
+}
+
+func readMultipartFields(t *testing.T, body []byte, boundary string) map[string]string {
+	t.Helper()
+
+	reader := multipart.NewReader(bytes.NewReader(body), boundary)
+	fields := make(map[string]string)
+	for {
+		part, err := reader.NextPart()
+		if err == io.EOF {
+			return fields
+		}
+		if err != nil {
+			t.Fatalf("NextPart returned error: %v", err)
+		}
+
+		data, err := io.ReadAll(part)
+		if err != nil {
+			t.Fatalf("ReadAll returned error: %v", err)
+		}
+		fields[part.FormName()] = string(data)
+	}
+}

utils/utils.go

@@ -0,0 +1,16 @@
+package utils
+
+import (
+	"os"
+
+	"git.nix13.pw/scuroneko/slog"
+)
+
+// GetLoggerLevel returns DEBUG when DEBUG=true in env, otherwise FATAL.
+func GetLoggerLevel() slog.LogLevel {
+	level := slog.FATAL
+	if os.Getenv("DEBUG") == "true" {
+		level = slog.DEBUG
+	}
+	return level
+}

utils/version.go

@@ -0,0 +1,9 @@
+package utils
+
+const (
+	VersionString = "1.0.0-beta.22"
+	VersionMajor  = 1
+	VersionMinor  = 0
+	VersionPatch  = 0
+	VersionBeta   = 22
+)