HotFix

2026-04-09 12:04:42 +02:00 · 2026-04-09 11:56:40 +02:00 · 2026-04-09 11:56:29 +02:00 · 2026-04-09 11:18:47 +02:00 · 2026-04-09 11:16:45 +02:00 · 2026-04-09 11:12:41 +02:00
69 changed files with 2916 additions and 134 deletions
--- a/.gitea/workflows/publish.yml
+++ b/.gitea/workflows/publish.yml
@@ -0,0 +1,30 @@
+name: Publish to NPM
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+    build-and-publish:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+            
+            - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                node-version: "24"
+
+            - name: Install dependencies
+              run: npm ci
+
+            - name: Build TypeScript
+              run: npm run build
+            
+            - name: Add NPM token
+              run: echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc
+
+            - name: Publish to NPM
+              run: npm publish --access public
--- a/.gitignore
+++ b/.gitignore
@@ -13,4 +13,5 @@ yarn-error.log*
 .DS_Store
 .env
 .env.*
-!.env.example
+!.env.example
+/dist
--- a/655
+++ b/655
@@ -0,0 +1,655 @@
+                    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.
+
+    Chatenium SDK TypeScript
+    Copyright (C) 2026  Chatenium
+
+    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/>.
+
+  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>.
--- a/README.md
+++ b/README.md
@@ -0,0 +1,6 @@
+# Chatenium SDK For TypeScript
+A library for interacting with the Chatenium API.
+## Quick Start
+```aiignore
+npm install @chatenium/chatenium-sdk
+```
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
-  "name": "chatenium-sdk",
-  "version": "1.0.0",
+  "name": "@chatenium/chatenium-sdk",
+  "version": "1.0.8",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
-      "name": "chatenium-sdk",
-      "version": "1.0.0",
+      "name": "@chatenium/chatenium-sdk",
+      "version": "1.0.8",
      "dependencies": {
        "@faker-js/faker": "^10.4.0",
        "axios": "^1.14.0",
--- a/package.json
+++ b/package.json
@@ -1,8 +1,28 @@
 {
-  "name": "chatenium-sdk",
-  "version": "1.0.0",
-  "description": "",
+  "name": "@chatenium/chatenium-sdk",
+  "version": "1.0.10",
+  "description": "A library for interacting with the Chatenium API",
+  "type": "module",
  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./core/*": "./dist/core/*.js",
+    "./services/*": "./dist/services/*.js",
+    "./domain/*": "./dist/domain/*.js",
+    "./mocks/*": "./dist/mocks/*.js",
+    "./storage/*": "./dist/storage/*.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
  "scripts": {
    "build": "tsc",
    "test": "vitest run",
@@ -15,7 +35,7 @@
    "typescript": "^5.5.3",
    "vitest": "^4.1.2"
  },
-  "private": true,
+  "private": false,
  "dependencies": {
    "@faker-js/faker": "^10.4.0",
    "axios": "^1.14.0",
--- a/src/core/environment.ts
+++ b/src/core/environment.ts
@@ -4,6 +4,9 @@ export interface SDKConfig {
    wsUrl: string;
 }

+declare const process: any;
+declare const require: any;
+
 const isNode =
    typeof process !== 'undefined' &&
    typeof process.versions !== 'undefined' &&
--- a/src/core/http.ts
+++ b/src/core/http.ts
@@ -1,5 +1,5 @@
 import axios, {AxiosInstance} from 'axios';
-import {environment} from "./environment";
+import {environment} from './environment.js';

 export const getClient = (cdn: boolean) => {
    const env = environment.get();
--- a/src/core/webSocketHandler.ts
+++ b/src/core/webSocketHandler.ts
@@ -4,12 +4,12 @@ import {
    WSMakeTokenReq,
    WSMakeTokenResp,
    WSMessagePayload
-} from "../domain/websocket.schema";
-import {getClient} from "./http";
-import {CreateNetworkReq, Network} from "../domain/networkService.schema";
+} from '../domain/websocket.schema.js';
+import {getClient} from './http.js';
+import {CreateNetworkReq, Network} from '../domain/networkService.schema.js';
 import {isAxiosError} from "axios";
-import {GenericErrorBody} from "../domain/http.schema";
-import {environment} from "./environment";
+import {GenericErrorBody} from '../domain/http.schema.js';
+import {environment} from './environment.js';

 export class WebSocketHandler {
    private static instance: WebSocketHandler;
@@ -64,9 +64,10 @@ export class WebSocketHandler {
                if (payl.action == "connectionId") {
                    console.log("ConnectionID received")
                    const data: WSConnIdPayload = JSON.parse(payl.data);
+                    this.connectionId = data.connId;
                    this.listeners.forEach(listener => {
+                        console.log(data.connId, listener)
                        listener.onNewConnId(data.connId)
-                        this.connectionId = data.connId;
                    })
                } else {
                    this.listeners.forEach(listener => {
@@ -78,6 +79,7 @@ export class WebSocketHandler {
    }

    public registerService(service: WSListenerPipe) {
+        console.log("Registering service", service)
        this.listeners.add(service);
    }

--- a/src/domain/broadcastChannelService.schema.ts
+++ b/src/domain/broadcastChannelService.schema.ts
@@ -0,0 +1,28 @@
+export interface CreateServerReq {
+    type: "rtmp",
+    channelId: string
+    categoryId: string
+    networkId: string
+}
+
+export interface GetRTMPDataReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface JoinWebsocketRoomReq {
+    userid: string
+    connId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface StreamRegistry {
+    streamKey: string
+    status: "idling" | "broadcasting" | "broadcasting_starting"
+    type: "rtmp"
+    streamURL: string
+    channelId: string
+}
--- a/src/domain/common.schema.ts
+++ b/src/domain/common.schema.ts
@@ -14,4 +14,14 @@ export interface PublicUserData {
    displayName: string
    username: string
    userid: string
+}
+
+export interface Attachment {
+    fileId: string
+    fileName: string
+    format: string
+    type: string
+    path: string
+    height: number
+    width: number
 }
--- a/src/domain/dmService.schema.ts
+++ b/src/domain/dmService.schema.ts
@@ -0,0 +1,112 @@
+import {Attachment, TimeStamp} from './common.schema.js';
+
+export interface GetMessageReq {
+    from: number
+    chatid: string
+}
+
+export interface GetMessagePosReq {
+    messageId: string
+    chatid: string
+}
+
+export interface GetPinnedMessagesReq {
+    chatid: string
+}
+
+export interface EditMessageReq {
+    message: string
+    messageId: string
+    chatid: string
+    userid: string
+}
+
+export interface FinishMessageReq {
+    uploadId: string | null
+    message: string
+    replyTo: string
+    replyToMessage: string
+    chatid: string
+    userid: string
+}
+
+export interface ReadMessagesReq {
+    chatid: string
+    userid: string
+}
+
+export interface PinMessageReq {
+    chatid: string
+    messageId: string
+    userid: string
+    message: string
+}
+
+export interface UnpinMessageReq {
+    chatid: string,
+    messageId: string,
+    userid: string
+}
+
+export interface DeleteMessagesReq {
+    messageIds: string[]
+    chatid: string
+    userid: string
+}
+
+export interface JoinWsRoomReq {
+    connId: string
+    chatid: string
+    userid: string
+}
+
+// Response schemas
+export interface GetMessagePosResp {
+    messagePos: number
+}
+
+// Types
+export interface Message {
+    msgid: string
+    author: string
+    message: string
+    sent_at: TimeStamp
+    isEdited: boolean
+    chatid: string
+    files: Attachment[]
+    seen: boolean
+    replyTo: string
+    replyToId: string
+    forwardedFrom: string
+    forwardedFromName: string
+}
+
+export interface PinnedMessage {
+    message: string
+    messageId: string
+}
+
+// WebSocket payloads
+export interface WSMessageDeletedPayload {
+    messageId: string
+}
+
+export interface WSMessageEditedPayload {
+    messageId: string
+    message: string
+}
+
+export interface WSMessagePinnedPayload {
+    chatid: string
+    messageId: string
+    message: string
+}
+
+export interface WSMessagesReadPayload {
+    userid: string
+}
+
+export interface WSMessageUnpinnedPayload {
+    chatid: string
+    messageId: string
+}
--- a/src/domain/fileTransferService.schema.ts
+++ b/src/domain/fileTransferService.schema.ts
@@ -0,0 +1,95 @@
+export interface StartNewFileTransferReq {
+    userid: string
+    targetUserId: string
+    metadata: TransferableFileMetadata[]
+}
+
+export interface AcceptFileTransferReq {
+    userid: string
+    senderId: string
+    transferId: string
+}
+
+export interface DeclineFileTransferReq {
+    userid: string
+    senderId: string
+    transferId: string
+}
+
+export interface FileTransferSendOfferRTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    offer: string
+}
+
+export interface FileTransferSendAnswerRTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    answer: string
+}
+
+export interface FileTransferSendICERTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    candidate: string
+}
+
+// Response schemas
+export interface StartNewFileTransferResp {
+    transferId: string
+}
+
+// WebSocket payloads
+export interface WSNewFileTransferPayload {
+    from: string
+    transferId: string
+    metadata: TransferableFileMetadata[]
+}
+
+export interface WSFileTransferAcceptedPayload {
+    transferId: string
+    rtcConfig: RTCConfiguration
+}
+
+export interface WSFileTransferDeclinedPayload {
+    transferId: string
+}
+
+export interface WSFileTransferRTCOfferPayload {
+    transferId: string
+    offer: string
+}
+
+export interface WSFileTransferRTCAnswerPayload {
+    transferId: string
+    answer: string
+}
+
+export interface WSFileTransferRTCIcePayload {
+    transferId: string
+    candidate: string
+}
+
+// DataChannel payloads
+export interface DCStartNewFilePayload {
+    fileId: string
+    fileIndex: number
+    fileName: string
+    totalChunks: number
+}
+
+export interface DCTransferFilePayload {
+    fileId: string
+    fileIndex: string
+    chunk: string
+}
+
+// Types
+export interface TransferableFileMetadata {
+    fileId: string
+    name: string
+    size: number
+}
--- a/src/domain/fileUploadService.schema.ts
+++ b/src/domain/fileUploadService.schema.ts
@@ -33,8 +33,13 @@ export interface FileUploadRegistration {
 }

 export interface FileData {
+    fileId: string
    name: string
    extension: string
    type: string
    data: File
+}
+
+export interface FileUploadProgressListener {
+    fileProgressUpdate: (fileId: string, allChunks: number, chunksDone: number) => void
 }
--- a/src/domain/networkService.schema.ts
+++ b/src/domain/networkService.schema.ts
@@ -1,5 +1,5 @@
 // Request schemas
-import {PublicUserData, RGB, TimeStamp} from "./common.schema";
+import {PublicUserData, RGB, TimeStamp} from './common.schema.js';

 export interface GetInvitesReq {
    networkId: string
--- a/src/domain/pictureService.schema.ts
+++ b/src/domain/pictureService.schema.ts
@@ -1,4 +1,4 @@
-import {PublicUserData, TimeStamp} from "./common.schema";
+import {PublicUserData, TimeStamp} from './common.schema.js';

 // Request schemas
 export interface GetReq {
--- a/src/domain/sessionManager.schema.ts
+++ b/src/domain/sessionManager.schema.ts
@@ -0,0 +1,19 @@
+import {PublicUserData} from './common.schema.js';
+import {GIF, PersonalUserData} from './userService.schema.js';
+
+export interface Session {
+    userData: PersonalUserData
+    token: string
+}
+
+export interface ValidateSessionReq {
+    token: string
+}
+
+export interface ValidateSessionResp {
+    validationOk: boolean
+}
+
+export interface UpdateUserDataReq {
+    userid: string
+}
--- a/src/domain/textChannelService.schema.ts
+++ b/src/domain/textChannelService.schema.ts
@@ -0,0 +1,138 @@
+import {Attachment, PublicUserData, TimeStamp} from './common.schema.js';
+
+export interface GetMessageReq {
+    from: number
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface GetMessagePosReq {
+    messageId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface GetPinnedMessagesReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface EditMessageReq {
+    message: string
+    messageId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface FinishMessageReq {
+    uploadId: string | null
+    message: string
+    replyTo: string
+    replyToMessage: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface ReadMessagesReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface PinMessageReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+    userid: string
+    message: string
+}
+
+export interface UnpinMessageReq {
+    channelId: string
+    networkId: string
+    categoryId: string,
+    messageId: string,
+    userid: string
+}
+
+export interface DeleteMessagesReq {
+    messageIds: string[]
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface JoinWsRoomReq {
+    connId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+// Response schemas
+export interface GetMessagePosResp {
+    messagePos: number
+}
+
+// Types
+export interface Message {
+    msgid: string
+    author: PublicUserData
+    message: string
+    sent_at: TimeStamp
+    isEdited: boolean
+    channelId: string
+    networkId: string
+    categoryId: string
+    files: Attachment[]
+    seen: boolean
+    replyTo: string
+    replyToId: string
+    forwardedFrom: string
+    forwardedFromName: string
+}
+
+export interface PinnedMessage {
+    message: string
+    messageId: string
+}
+
+// WebSocket payloads
+export interface WSMessageDeletedPayload {
+    messageId: string
+}
+
+export interface WSMessageEditedPayload {
+    messageId: string
+    message: string
+}
+
+export interface WSMessagePinnedPayload {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+    message: string
+}
+
+export interface WSMessagesReadPayload {
+    userid: string
+}
+
+export interface WSMessageUnpinnedPayload {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+}
--- a/src/domain/userService.schema.ts
+++ b/src/domain/userService.schema.ts
@@ -0,0 +1,114 @@
+import {TimeStamp} from './common.schema.js';
+
+export interface ChangeUsernameReq {
+    newUsername: string;
+    userid: string;
+}
+
+export interface ChangeDisplayNameReq {
+    newDisplayName: string;
+    userid: string;
+}
+
+export interface ChangePasswordReq {
+    newPassword: string;
+    currentPassword: string;
+    userid: string;
+}
+
+export interface ChangeEmailReq {
+    currentPassword: string;
+    newMail: string;
+    userid: string;
+}
+
+export interface VerifyMailChangeReq {
+    userid: string;
+    vCodeCurrent: number;
+    vCodeNew: number;
+    newAddress: string;
+}
+
+export interface ChangePhoneReq {
+    currentPassword: string;
+    newPhone: string;
+    userid: string;
+}
+
+export interface VerifyPhoneChange {
+    userid: string;
+    vCodeCurrent: number;
+    vCodeNew: number;
+    newPhone: string;
+}
+
+export interface UploadNewPfpReq {
+    userid: string;
+    pfpId: string;
+}
+
+export interface UploadNewPfpCdnReq {
+    userid: string;
+    data: string | null;
+    isImage: boolean;
+    monogramLetter: string | null;
+    monogramColors: string | null;
+}
+
+export interface DeleteReq {
+    userid: string;
+    password: string;
+}
+
+export interface RegisterFCMTokenReq {
+    userid: string;
+    token: string;
+    language: string;
+}
+
+export interface GetSessionsReq {
+    userid: string;
+}
+
+export interface UpdateUserDataReq {
+    userid: string;
+}
+
+export interface ToggleGifSaveReq {
+    userid: string;
+    url: string;
+}
+
+export interface UploadNewPfpCdnResp {
+    pfpId: string;
+}
+
+export interface Session {
+    token: string;
+    os: string;
+    language: string;
+    login_at: TimeStamp | string;
+}
+
+export interface GIF {
+    gifId: string;
+    url: string;
+    path: string;
+}
+
+export interface CurrNewCodeTestingResp {
+    codeCurr: number|null;
+    codeNew: number|null;
+}
+
+export interface PersonalUserData {
+    userid: string;
+    username: string;
+    displayName: string;
+    pfp: string;
+    pictureDiscovery: boolean;
+    gifs: GIF[];
+    passwordSet: boolean;
+    emailSet: boolean;
+    phoneSet: boolean;
+}
--- a/src/mocks/handlers/auth.http.ts
+++ b/src/mocks/handlers/auth.http.ts
@@ -5,8 +5,8 @@ import {
    OtpSendCodeReq,
    OtpVerifyCodeReq, PleVerifyCodeReq, PleVerifyCodeResp, RegisterReq, SignInSuccessResp,
    UserDataValidationResp, VerifyPasswordResetReq
-} from "../../domain/authService.schema";
-import {GenericSuccessBody} from "../../domain/http.schema";
+} from '../../domain/authService.schema.js';
+import {GenericSuccessBody} from '../../domain/http.schema.js';

 export const networkHandlers = [
    http.get('*/user/authOptions', () => {
--- a/src/mocks/handlers/brcChan.http.ts
+++ b/src/mocks/handlers/brcChan.http.ts
@@ -0,0 +1,11 @@
+import {http, HttpResponse} from "msw";
+import {GetRTCAccessResp} from '../../domain/callService.schema.js';
+import {StreamRegistry} from '../../domain/broadcastChannelService.schema.js';
+
+export const brcChanHandlers = [
+    http.get('*/network/channel/rtmpData', () => {
+        return HttpResponse.json(<StreamRegistry>{
+            status: "broadcasting_starting"
+        })
+    }),
+]
--- a/src/mocks/handlers/call.http.ts
+++ b/src/mocks/handlers/call.http.ts
@@ -1,5 +1,5 @@
 import {http, HttpResponse} from "msw";
-import {GetRTCAccessResp} from "../../domain/callService.schema";
+import {GetRTCAccessResp} from '../../domain/callService.schema.js';

 export const callHandlers = [
    http.post('*/v2/chat/getRTCAccess', () => {
--- a/src/mocks/handlers/chat.http.ts
+++ b/src/mocks/handlers/chat.http.ts
@@ -1,5 +1,5 @@
 import {http, HttpResponse} from "msw";
-import {Chat, GetAvailabilityResp, StartNewReq} from "../../domain/chatService.schema";
+import {Chat, GetAvailabilityResp, StartNewReq} from '../../domain/chatService.schema.js';

 export const chatHandlers = [
    http.get('*/chat/get', () => {
--- a/src/mocks/handlers/dm.http.ts
+++ b/src/mocks/handlers/dm.http.ts
@@ -0,0 +1,35 @@
+import {http, HttpResponse} from "msw";
+import {Chat} from '../../domain/chatService.schema.js';
+import {FinishMessageReq, GetMessagePosResp, Message, PinnedMessage} from '../../domain/dmService.schema.js';
+import {CreateNetworkReq, Network} from '../../domain/networkService.schema.js';
+
+export const dmHandlers = [
+    http.get('*/chat/dm/messages', () => {
+        return HttpResponse.json(<Message[]>[{
+            message: "This is a message",
+        }])
+    }),
+
+    http.get('*/chat/dm/getMessagePosition', () => {
+        return HttpResponse.json(<GetMessagePosResp>{
+            messagePos: 5000
+        })
+    }),
+
+    http.get('*/chat/dm/pinnedMessages', () => {
+        return HttpResponse.json(<PinnedMessage[]>[{
+            message: "This is a pinned message",
+        }])
+    }),
+
+    http.post('*/chat/dm/finishMessage', async ({request}) => {
+        const body = await request.json() as FinishMessageReq
+        return HttpResponse.json(<Message>{
+            message: body.message,
+        })
+    }),
+
+    http.post('*/v2/chat/dm/joinWebSocketRoom', async () => {
+        return HttpResponse.json()
+    }),
+]
--- a/src/mocks/handlers/fUpl.http.ts
+++ b/src/mocks/handlers/fUpl.http.ts
@@ -1,6 +1,6 @@
 import {http, HttpResponse} from "msw";
-import {GetRTCAccessResp} from "../../domain/callService.schema";
-import {RegisterUploadResp} from "../../domain/fileUploadService.schema";
+import {GetRTCAccessResp} from '../../domain/callService.schema.js';
+import {RegisterUploadResp} from '../../domain/fileUploadService.schema.js';

 export const fileUploadHandlers = [
    http.post('*/chat/cdnRegisterUpload', () => {
--- a/src/mocks/handlers/network.http.ts
+++ b/src/mocks/handlers/network.http.ts
@@ -5,8 +5,8 @@ import {
    Network,
    NetworkCategory,
    NetworkInvite, POW
-} from "../../domain/networkService.schema";
-import {PublicUserData} from "../../domain/common.schema";
+} from '../../domain/networkService.schema.js';
+import {PublicUserData} from '../../domain/common.schema.js';

 export const authHandlers = [
    http.get('*/network/invites', () => {
--- a/src/mocks/handlers/picture.http.ts
+++ b/src/mocks/handlers/picture.http.ts
@@ -1,6 +1,6 @@
 import {http, HttpResponse} from "msw";
-import {CreateNetworkReq, Network, NetworkInvite} from "../../domain/networkService.schema";
-import {Album, Comment, CreateAlbumReq, GetResp} from "../../domain/pictureService.schema";
+import {CreateNetworkReq, Network, NetworkInvite} from '../../domain/networkService.schema.js';
+import {Album, Comment, CreateAlbumReq, GetResp} from '../../domain/pictureService.schema.js';

 export const pictureHandlers = [
    http.get('*/picture/pictures', () => {
--- a/src/mocks/handlers/user.http.ts
+++ b/src/mocks/handlers/user.http.ts
@@ -0,0 +1,11 @@
+import {http, HttpResponse} from "msw";
+import {GetResp} from '../../domain/pictureService.schema.js';
+import {Session} from '../../domain/userService.schema.js';
+
+export const userHandler = [
+    http.post('*/user/getSessions', () => {
+        return HttpResponse.json(<Session[]>[{
+            token: "sessionToken"
+        }])
+    }),
+]
--- a/src/mocks/index.ts
+++ b/src/mocks/index.ts
@@ -1,9 +1,12 @@
-import {networkHandlers} from "./handlers/auth.http";
-import {authHandlers} from "./handlers/network.http";
-import {pictureHandlers} from "./handlers/picture.http";
-import {callHandlers} from "./handlers/call.http";
-import {fileUploadHandlers} from "./handlers/fUpl.http";
-import {chatHandlers} from "./handlers/chat.http";
+import {networkHandlers} from './handlers/auth.http.js';
+import {authHandlers} from './handlers/network.http.js';
+import {pictureHandlers} from './handlers/picture.http.js';
+import {callHandlers} from './handlers/call.http.js';
+import {fileUploadHandlers} from './handlers/fUpl.http.js';
+import {chatHandlers} from './handlers/chat.http.js';
+import {dmHandlers} from './handlers/dm.http.js';
+import {userHandler} from './handlers/user.http.js';
+import {brcChanHandlers} from './handlers/brcChan.http.js';

 export const allHandlers = [
    ...authHandlers,
@@ -11,5 +14,8 @@ export const allHandlers = [
    ...pictureHandlers,
    ...callHandlers,
    ...fileUploadHandlers,
-    ...chatHandlers
+    ...chatHandlers,
+    ...dmHandlers,
+    ...userHandler,
+    ...brcChanHandlers
 ]
--- a/src/mocks/node.ts
+++ b/src/mocks/node.ts
@@ -1,4 +1,4 @@
 import {setupServer} from "msw/node";
-import {allHandlers} from "./index";
+import {allHandlers} from './index.js';

 export const mockServer = setupServer(...allHandlers)
--- a/src/mocks/storage/database.ts
+++ b/src/mocks/storage/database.ts
@@ -1,9 +1,12 @@
-import {DatabaseAPI} from "../../storage/database";
+import {DatabaseAPI} from '../../storage/database.js';

 export class DatabaseMock implements DatabaseAPI {
    database: { [collection: string]: { [key: string]: string } } = {};

    set(collection: string, key: string, value: any) {
+        if (!this.database[collection]) {
+            this.database[collection] = {};
+        }
        this.database[collection][key] = JSON.stringify(value);
    }

--- a/src/mocks/storage/keyring.ts
+++ b/src/mocks/storage/keyring.ts
@@ -1,4 +1,4 @@
-import {KeyringAPI} from "../../storage/keyring";
+import {KeyringAPI} from '../../storage/keyring.js';

 export class KeyringMock implements KeyringAPI {
    ring: { [key: string]: string } = {};
@@ -7,15 +7,15 @@ export class KeyringMock implements KeyringAPI {
        this.ring[key] = value;
    }

-    get(key: string): string {
-        return this.ring[key];
+    get(key: string): Promise<string> {
+        return Promise.resolve(this.ring[key]);
+    }
+
+    getAll(): Promise<string[]> {
+        return Promise.resolve(Object.keys(this.ring));
    }

    delete(key: string) {
        delete this.ring[key];
    }
-
-    flush() {
-        this.ring = {};
-    }
 }
--- a/src/services/authService.test.ts
+++ b/src/services/authService.test.ts
@@ -1,6 +1,6 @@
 import {describe, expect, it} from "vitest";
-import {AuthService} from "./authService";
-import {VerificationTypeEmail} from "../domain/authService.schema";
+import {AuthService} from './authService.js';
+import {VerificationTypeEmail} from '../domain/authService.schema.js';
 import {faker} from "@faker-js/faker/locale/en";

 describe("AuthService", () => {
--- a/src/services/authService.ts
+++ b/src/services/authService.ts
@@ -1,4 +1,4 @@
-import {getClient} from "../core/http";
+import {getClient} from '../core/http.js';
 import {
    AuthMethods, FinishPleAccountReq,
    LoginPasswordAuthReq, LoginWithApple, LoginWithGoogleReq, OtpPleCodeSendTestingResp,
@@ -6,9 +6,9 @@ import {
    OtpVerifyCodeReq, PleSendCodeReq,
    PleVerifyCodeReq, PleVerifyCodeResp, RegisterReq, ResetPasswordReq, ResetPasswordResp,
    SignInSuccessResp, UserDataValidationResp, VerifyPasswordResetReq
-} from "../domain/authService.schema";
+} from '../domain/authService.schema.js';
 import {isAxiosError} from "axios";
-import {GenericErrorBody, GenericSuccessBody} from "../domain/http.schema";
+import {GenericErrorBody, GenericSuccessBody} from '../domain/http.schema.js';

 export class AuthService {
    /**
@@ -164,7 +164,6 @@ export class AuthService {
            });
            return resp.data.authCode
        } catch (e) {
-            console.log(e)
            if (isAxiosError<GenericErrorBody>(e)) {
                throw e;
            }
--- a/src/services/broadcastChannelService.test.ts
+++ b/src/services/broadcastChannelService.test.ts
@@ -0,0 +1,11 @@
+import {describe, expect, it} from "vitest";
+import {BroadcastChannelService} from './broadcastChannelService.js';
+
+describe("BroadcastChannelService", () => {
+    const service = new BroadcastChannelService("", "", "", "", "", () => {})
+
+    it("should get stream registry data", async () => {
+        const data = await service.getData()
+        expect(data.status).toBe("broadcasting_starting")
+    })
+})
--- a/src/services/broadcastChannelService.ts
+++ b/src/services/broadcastChannelService.ts
@@ -0,0 +1,93 @@
+import {AxiosInstance, isAxiosError} from "axios";
+import {getClient} from '../core/http.js';
+import {MessageListener} from '../domain/websocket.schema.js';
+import {WebSocketHandler} from '../core/webSocketHandler.js';
+import {AcceptInviteReq} from '../domain/networkService.schema.js';
+import {GenericErrorBody} from '../domain/http.schema.js';
+import {
+    CreateServerReq,
+    GetRTMPDataReq,
+    JoinWebsocketRoomReq,
+    StreamRegistry
+} from '../domain/broadcastChannelService.schema.js';
+
+export class BroadcastChannelService {
+    userid: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    client: AxiosInstance;
+
+    constructor(token: string, userid: string, networkId: string, categoryId: string, channelId: string, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.channelId = channelId;
+        this.categoryId = categoryId;
+        this.networkId = networkId;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: channelId,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    async getData(): Promise<StreamRegistry> {
+        try {
+            const resp = await this.client.get<StreamRegistry>(`network/channel/rtmpData?userid=${this.userid}&channelId=${this.channelId}&networkId=${this.networkId}&categoryId=${this.categoryId}`);
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async createServer(): Promise<StreamRegistry> {
+        try {
+            const resp = await this.client.post<StreamRegistry>("network/channel/createServer", <CreateServerReq>{
+                userid: this.userid,
+                channelId: this.channelId,
+                networkId: this.networkId,
+                type: "rtmp",
+                categoryId: this.categoryId,
+            });
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+            await this.client.post("v2/network/channel/joinWebSocketRoom", <JoinWebsocketRoomReq>{
+                userid: this.userid,
+                channelId: this.channelId,
+                networkId: this.networkId,
+                connId: WebSocketHandler.getInstance().connId,
+                categoryId: this.categoryId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/callService.test.ts
+++ b/src/services/callService.test.ts
@@ -1,5 +1,5 @@
 import {describe, expect, it} from "vitest";
-import {CallService} from "./callService";
+import {CallService} from './callService.js';

 describe("CallService", () => {
    const handler = new CallService("", "")
--- a/src/services/callService.ts
+++ b/src/services/callService.ts
@@ -1,8 +1,8 @@
-import {getClient} from "../core/http";
-import {OtpPleCodeSendTestingResp, OtpSendCodeReq} from "../domain/authService.schema";
+import {getClient} from '../core/http.js';
+import {OtpPleCodeSendTestingResp, OtpSendCodeReq} from '../domain/authService.schema.js';
 import {isAxiosError} from "axios";
-import {GenericErrorBody} from "../domain/http.schema";
-import {GetRTCAccessReq, GetRTCAccessResp, InviteToCallReq} from "../domain/callService.schema";
+import {GenericErrorBody} from '../domain/http.schema.js';
+import {GetRTCAccessReq, GetRTCAccessResp, InviteToCallReq} from '../domain/callService.schema.js';

 export class CallService {
    userid: string;
--- a/src/services/chatService.test.ts
+++ b/src/services/chatService.test.ts
@@ -1,6 +1,6 @@
 import {describe, expect, it} from "vitest";
-import {ChatService} from "./chatService";
-import {DatabaseMock} from "../mocks/storage/database";
+import {ChatService} from './chatService.js';
+import {DatabaseMock} from '../mocks/storage/database.js';
 import {faker} from "@faker-js/faker/locale/en";

 describe("ChatService", () => {
--- a/src/services/chatService.ts
+++ b/src/services/chatService.ts
@@ -1,17 +1,18 @@
-import {DatabaseAPI} from "../storage/database";
-import {MessageListener} from "../domain/websocket.schema";
-import {getClient} from "../core/http";
-import {WebSocketHandler} from "../core/webSocketHandler";
+import {DatabaseAPI} from '../storage/database.js';
+import {MessageListener} from '../domain/websocket.schema.js';
+import {getClient} from '../core/http.js';
+import {WebSocketHandler} from '../core/webSocketHandler.js';
 import {AxiosInstance, isAxiosError} from "axios";
-import {NetworkInvite} from "../domain/networkService.schema";
-import {GenericErrorBody} from "../domain/http.schema";
+import {NetworkInvite} from '../domain/networkService.schema.js';
+import {GenericErrorBody} from '../domain/http.schema.js';
 import {
    Chat,
    GetAvailabilityReq,
    GetAvailabilityResp,
    StartNewReq,
    ToggleChatMuteReq
-} from "../domain/chatService.schema";
+} from '../domain/chatService.schema.js';
+import {Message} from '../domain/dmService.schema.js';

 /**
 * ChatService is an exception because it's one instance for all chats because it's unnecessary to create a new instance for each chat
@@ -47,9 +48,9 @@ export class ChatService {
    async get(): Promise<Chat[]> {
        try {
            const resp = await this.client.get<Chat[]>(`chat/get?userid=${this.userid}`);
+            this.database.set("chats", this.userid, JSON.stringify(resp.data))
            return resp.data
        } catch (e) {
-            console.log(e)
            if (isAxiosError<GenericErrorBody>(e)) {
                throw e;
            }
@@ -57,6 +58,15 @@ export class ChatService {
        }
    }

+    async getQuick(): Promise<Message[]> {
+        const chats = await this.database.get("chats", this.userid)
+        if (chats) {
+            return JSON.parse(chats)
+        } else {
+            throw new Error("No chats in database")
+        }
+    }
+
    /**
     * Gets the availability of the specified user
     * @param userid
--- a/src/services/dmService.test.ts
+++ b/src/services/dmService.test.ts
@@ -0,0 +1,29 @@
+import {describe, expect, it} from "vitest";
+import {DMService} from './dmService.js';
+import {DatabaseMock} from '../mocks/storage/database.js';
+import {faker} from "@faker-js/faker/locale/en";
+
+describe("DmService", () => {
+    const service = new DMService("", "", "", new DatabaseMock(), () => {})
+
+    it("should get messages", async () => {
+        const messages = await service.get()
+        expect(messages[0].message).toBe("This is a message")
+    })
+
+    it('should get message position', async () => {
+        const pos = await service.getMessagePos("")
+        expect(pos).toBe(5000)
+    });
+
+    it('should get pinned messages', async () => {
+        const pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages[0].message).toBe("This is a pinned message")
+    });
+
+    it('should send a new message', async () => {
+        const message = faker.internet.displayName()
+        const newMessage = await service.sendMessage(message)
+        expect(newMessage.message).toBe(message)
+    });
+})
--- a/src/services/dmService.ts
+++ b/src/services/dmService.ts
@@ -0,0 +1,261 @@
+import {DatabaseAPI} from '../storage/database.js';
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from '../domain/websocket.schema.js';
+import {getClient} from '../core/http.js';
+import {WebSocketHandler} from '../core/webSocketHandler.js';
+import {
+    DeleteMessagesReq,
+    EditMessageReq,
+    FinishMessageReq,
+    GetMessagePosResp, JoinWsRoomReq,
+    Message, PinMessageReq,
+    PinnedMessage, ReadMessagesReq, UnpinMessageReq
+} from '../domain/dmService.schema.js';
+import {NetworkInvite} from '../domain/networkService.schema.js';
+import {GenericErrorBody} from '../domain/http.schema.js';
+import {FileData, FileUploadProgressListener} from '../domain/fileUploadService.schema.js';
+import {FileUploadService} from './fileUploadService.js';
+
+export class DMService {
+    userid: string;
+    chatid: string;
+    token: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, chatid: string, database: DatabaseAPI, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.chatid = chatid;
+        this.database = database;
+        this.token = token;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: chatid,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("DmService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+        this.joinWebSocketRoom().then()
+    }
+
+    /**
+     * Fetches all messages in the chat
+     * @param from
+     */
+    async get(from: number = 0): Promise<Message[]> {
+        try {
+            const resp = await this.client.get<Message[]>(`chat/dm/messages?chatid=${this.chatid}&userid=${this.userid}&from=${from}`);
+            if (from == 0) {
+                this.database.set("messages", this.chatid, JSON.stringify(resp.data))
+            }
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async getQuick(): Promise<Message[]> {
+        const messages = await this.database.get("messages", this.chatid)
+        if (messages) {
+            return JSON.parse(messages)
+        } else {
+            throw new Error("No messages in database")
+        }
+    }
+
+    /**
+     * Fetches the position of the specified message which can be used in get() to fetch an old message with it's surrounding messages
+     * @param messageId
+     */
+    async getMessagePos(messageId: string): Promise<number> {
+        try {
+            const resp = await this.client.get<GetMessagePosResp>(`chat/dm/getMessagePosition?chatid=${this.chatid}&userid=${this.userid}&messageId=${messageId}`);
+            return resp.data.messagePos
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets all messages pinned in the chat
+     */
+    async getPinnedMessages(): Promise<PinnedMessage[]> {
+        try {
+            const resp = await this.client.get<PinnedMessage[]>(`chat/dm/pinnedMessages?chatid=${this.chatid}&userid=${this.userid}`);
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Edits the specified message
+     * @param messageId
+     * @param newMessage
+     */
+    async editMessage(messageId: string, newMessage: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/editMessage", <EditMessageReq>{
+                messageId: messageId,
+                chatid: this.chatid,
+                userid: this.userid,
+                message: newMessage
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Sends a new message to the chat
+     * @param message
+     * @param replyTo
+     * @param replyToMessage
+     * @param attachments
+     * @param progressListener
+     */
+    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null, progressListener: FileUploadProgressListener | null = null): Promise<Message> {
+        let uploadId = ""
+        if (attachments) {
+            const uploader = new FileUploadService(this.token)
+            uploadId = await uploader.uploadFiles(this.chatid, this.userid, attachments, progressListener!)
+        }
+        try {
+            const resp = await this.client.post<Message>("chat/dm/finishMessage", <FinishMessageReq>{
+                message: message,
+                chatid: this.chatid,
+                replyTo: replyTo,
+                replyToMessage: replyToMessage,
+                userid: this.userid,
+                uploadId: uploadId,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Reads all messages sent to you in the chat
+     */
+    async readMessages(): Promise<void> {
+        try {
+            await this.client.patch("chat/dm/readMessages", <ReadMessagesReq>{
+                chatid: this.chatid,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Pins the specified message
+     * @param messageId
+     * @param message
+     */
+    async pinMessage(messageId: string, message: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/pinMessage", <PinMessageReq>{
+                messageId: messageId,
+                chatid: this.chatid,
+                userid: this.userid,
+                message: message
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Unpins the specified message
+     * @param messageId
+     */
+    async unpinMessage(messageId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/unpinMessage", <UnpinMessageReq>{
+                messageId: messageId,
+                chatid: this.chatid,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes the message(s)
+     * @param messageIds
+     */
+    async deleteMessages(messageIds: string[]): Promise<void> {
+        try {
+            const resp = await this.client.patch("chat/dm/deleteMessages", <DeleteMessagesReq>{
+                chatid: this.chatid,
+                userid: this.userid,
+                messageIds: messageIds
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Joins the WebSocket room to start receiving realtime messages
+     */
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+           await this.client.post("v2/chat/dm/joinWebSocketRoom", <JoinWsRoomReq>{
+                chatid: this.chatid,
+                userid: this.userid,
+                connId: WebSocketHandler.getInstance().connId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/fileTransferService.ts
+++ b/src/services/fileTransferService.ts
@@ -0,0 +1,156 @@
+import {DatabaseAPI} from '../storage/database.js';
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from '../domain/websocket.schema.js';
+import {getClient} from '../core/http.js';
+import {WebSocketHandler} from '../core/webSocketHandler.js';
+import {CreateNetworkReq, Network} from '../domain/networkService.schema.js';
+import {GenericErrorBody} from '../domain/http.schema.js';
+import {
+    AcceptFileTransferReq, DeclineFileTransferReq, FileTransferSendAnswerRTCReq,
+    FileTransferSendICERTCReq, FileTransferSendOfferRTCReq,
+    StartNewFileTransferReq,
+    StartNewFileTransferResp,
+    TransferableFileMetadata
+} from '../domain/fileTransferService.schema.js';
+
+export class FileTransferService {
+    userid: string;
+    peerId: string;
+    transferId: string = "";
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, peerId: string) {
+        this.userid = userid;
+        this.peerId = peerId;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+            }
+        })
+    }
+
+    /**
+     * Starts a new file transfer with the specified user. The new transferId will be saved automatically and not required to be provided later.
+     * @param transferableFiles
+     */
+    async startNew(transferableFiles: TransferableFileMetadata[]): Promise<string> {
+        try {
+            const resp = await this.client.post<StartNewFileTransferResp>("v2/chat/dm/startNewFileTransfer", <StartNewFileTransferReq>{
+                userid: this.userid,
+                targetUserId: this.peerId,
+                metadata: transferableFiles
+            });
+            this.transferId = resp.data.transferId
+            return resp.data.transferId
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Accepts the file transfer with the specified transferId. The transferId will be saved automatically and not required to be provided later.
+     * @param transferId
+     */
+    async accept(transferId: string): Promise<RTCConfiguration> {
+        try {
+            const resp = await this.client.post<RTCConfiguration>("v2/chat/dm/acceptFileTransfer", <AcceptFileTransferReq>{
+                userid: this.userid,
+                senderId: this.peerId,
+                transferId: transferId
+            });
+            this.transferId = transferId
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Declines the file transfer with the specified transferId.
+     * @param transferId
+     */
+    async decline(transferId: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/declineFileTransfer", <DeclineFileTransferReq>{
+                userid: this.userid,
+                senderId: this.peerId,
+                transferId: transferId
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC offer to the specified user.
+     * @param offer
+     */
+    async sendRtcOffer(offer: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcOfferFileTransfer", <FileTransferSendOfferRTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                offer: offer,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC answer to the specified user.
+     * @param answer
+     */
+    async sendRtcAnswer(answer: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcAnswerFileTransfer", <FileTransferSendAnswerRTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                answer: answer,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC ICE candidate to the specified user.
+     * @param candidate
+     */
+    async sendRtcICE(candidate: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcICEFileTransfer", <FileTransferSendICERTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                candidate: candidate,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/fileUploadService.test.ts
+++ b/src/services/fileUploadService.test.ts
@@ -1,10 +1,12 @@
 import {describe, expect, it} from "vitest";
-import {FileUploadService} from "./fileUploadService";
+import {FileUploadService} from './fileUploadService.js';

 describe("fileUploadService", () => {
    it('should upload files', async () => {
        const service = new FileUploadService("");
-        const uploadId = await service.uploadFiles("", "", [])
+        const uploadId = await service.uploadFiles("", "", [], {
+            fileProgressUpdate: () => {}
+        })
        expect(uploadId).toBe("MockUploadId")
    });
 })
--- a/src/services/fileUploadService.ts
+++ b/src/services/fileUploadService.ts
@@ -1,14 +1,14 @@
 import {
    ChunkUploadReq,
-    FileData,
+    FileData, FileUploadProgressListener,
    FileUploadRegistration, FinishUploadReq,
    RegisterUploadReq,
    RegisterUploadResp
-} from "../domain/fileUploadService.schema";
+} from '../domain/fileUploadService.schema.js';
 import {AxiosInstance, isAxiosError} from "axios";
-import {getClient} from "../core/http";
-import {InviteToCallReq} from "../domain/callService.schema";
-import {GenericErrorBody} from "../domain/http.schema";
+import {getClient} from '../core/http.js';
+import {InviteToCallReq} from '../domain/callService.schema.js';
+import {GenericErrorBody} from '../domain/http.schema.js';
 import {v4 as uuidv4} from 'uuid';

 export class FileUploadService {
@@ -42,13 +42,14 @@ export class FileUploadService {
     * @param roomId chatid or channelId
     * @param userid
     * @param files
+     * @param listener
     */
-    async uploadFiles(roomId: string, userid: string, files: FileData[]): Promise<string> {
+    async uploadFiles(roomId: string, userid: string, files: FileData[], listener: FileUploadProgressListener): Promise<string> {
        let registrations: FileUploadRegistration[] = [];

        files.forEach(file => {
            registrations.push({
-                fileId: uuidv4(),
+                fileId: file.fileId,
                name: file.name,
                type: file.type,
                size: file.data.size,
@@ -62,7 +63,7 @@ export class FileUploadService {
                files: registrations,
            });
            for (let filesUploaded = 0; filesUploaded < files.length; filesUploaded++) {
-                await this.uploadFile(resp.data.uploadId, roomId, userid, files[filesUploaded], registrations[filesUploaded])
+                await this.uploadFile(resp.data.uploadId, roomId, userid, files[filesUploaded], registrations[filesUploaded], listener)
            }
            await this.finishUpload(roomId, userid, resp.data.uploadId)
            return resp.data.uploadId
@@ -92,7 +93,7 @@ export class FileUploadService {
        }
    }

-    private async uploadFile(uploadId: string, roomId: string, userid: string, file: FileData, registration: FileUploadRegistration): Promise<void> {
+    private async uploadFile(uploadId: string, roomId: string, userid: string, file: FileData, registration: FileUploadRegistration, listener: FileUploadProgressListener): Promise<void> {
        const chunkSize = this.calculateChunkSize(file.data.size);
        const totalChunks = Math.ceil(file.data.size / chunkSize);

@@ -104,6 +105,7 @@ export class FileUploadService {
            const chunk = new Uint8Array(arrayBuffer.slice(start, end));
            const base64 = this.uint8ToBase64(chunk);
            await this.uploadChunk(uploadId, roomId, userid, registration.fileId, base64);
+            listener.fileProgressUpdate(file.fileId, totalChunks, i)
        }
    }

--- a/src/services/networkService.test.ts
+++ b/src/services/networkService.test.ts
@@ -1,9 +1,9 @@
 import {describe, expect, it} from "vitest";
-import {NetworkService} from "./networkService";
-import {DatabaseMock} from "../mocks/storage/database";
+import {NetworkService} from './networkService.js';
+import {DatabaseMock} from '../mocks/storage/database.js';
 import {faker} from "@faker-js/faker/locale/en";
-import {getClient} from "../core/http";
-import {environment, SDKConfig} from "../core/environment";
+import {getClient} from '../core/http.js';
+import {environment, SDKConfig} from '../core/environment.js';

 describe("NetworkService", () => {
    const service = new NetworkService("", "", "", new DatabaseMock(), (action, data) => {})
--- a/src/services/networkService.ts
+++ b/src/services/networkService.ts
@@ -1,7 +1,7 @@
-import {DatabaseAPI} from "../storage/database";
-import {getClient} from "../core/http";
+import {DatabaseAPI} from '../storage/database.js';
+import {getClient} from '../core/http.js';
 import {AxiosInstance, isAxiosError} from "axios";
-import {GenericErrorBody} from "../domain/http.schema";
+import {GenericErrorBody} from '../domain/http.schema.js';
 import {
    AcceptInviteReq, AssignRankToMemberReq, BanMemberReq, ChangeVisibilityReq, CreateCategoryReq, CreateChannelReq,
    CreateInviteReq,
@@ -15,10 +15,11 @@ import {
    NetworkInvite, NetworkRank, OverwriteChannelPermissionReq, OverwritePermissionReq, PermissionUpdate, POW,
    RemoveRankFromMemberReq, ToggleCategoryMuteReq, ToggleChannelNetworkMuteReq, ToggleNetworkMuteReq,
    UnbanMemberReq, UploadNewPictureReq
-} from "../domain/networkService.schema";
-import {PublicUserData, RGB} from "../domain/common.schema";
-import {WebSocketHandler} from "../core/webSocketHandler";
-import {MessageListener} from "../domain/websocket.schema";
+} from '../domain/networkService.schema.js';
+import {PublicUserData, RGB} from '../domain/common.schema.js';
+import {WebSocketHandler} from '../core/webSocketHandler.js';
+import {MessageListener} from '../domain/websocket.schema.js';
+import {Message} from '../domain/dmService.schema.js';

 export class NetworkService {
    userid: string;
@@ -97,6 +98,7 @@ export class NetworkService {
            const resp = await this.client.post<Network[]>("network/get", <GetNetworksReq>{
                userid: this.userid,
            });
+            this.database.set("networks", this.userid, JSON.stringify(resp.data))
            return resp.data
        } catch (e) {
            if (isAxiosError<GenericErrorBody>(e)) {
@@ -106,6 +108,15 @@ export class NetworkService {
        }
    }

+    async getQuick(): Promise<Message[]> {
+        const networks = await this.database.get("networks", this.userid)
+        if (networks) {
+            return JSON.parse(networks)
+        } else {
+            throw new Error("No networks in database")
+        }
+    }
+
    /**
     * Accepts the invite and joins the network
     * @param inviteId
@@ -863,7 +874,7 @@ export class NetworkService {
    }

    /**
-     * Fetches network data from an invite
+     * Fetches network data from an invitation
     * @param inviteId
     */
    async getFromInvite(inviteId: string): Promise<Network> {
--- a/src/services/pictureService.test.ts
+++ b/src/services/pictureService.test.ts
@@ -1,6 +1,6 @@
 import {describe, expect, it} from "vitest";
-import {PictureService} from "./pictureService";
-import {DatabaseMock} from "../mocks/storage/database";
+import {PictureService} from './pictureService.js';
+import {DatabaseMock} from '../mocks/storage/database.js';
 import {faker} from "@faker-js/faker/locale/en";

 describe("PictureService", () => {
--- a/src/services/pictureService.ts
+++ b/src/services/pictureService.ts
@@ -1,8 +1,8 @@
-import {DatabaseAPI} from "../storage/database";
+import {DatabaseAPI} from '../storage/database.js';
 import {AxiosInstance, isAxiosError} from "axios";
-import {getClient} from "../core/http";
-import {NetworkInvite} from "../domain/networkService.schema";
-import {GenericErrorBody} from "../domain/http.schema";
+import {getClient} from '../core/http.js';
+import {NetworkInvite} from '../domain/networkService.schema.js';
+import {GenericErrorBody} from '../domain/http.schema.js';
 import {
    Album, ChangePictureVisibilityReq, Comment,
    CreateAlbumReq,
@@ -10,8 +10,9 @@ import {
    DiscoveryResp, EditPictureTitleReq,
    FinalizeUploadReq,
    GetResp, PostCommentReq, ToggleFollowReq, TogglePictureLikeReq, UploadImageReq
-} from "../domain/pictureService.schema";
-import {environment} from "../core/environment";
+} from '../domain/pictureService.schema.js';
+import {environment} from '../core/environment.js';
+import {Message} from '../domain/dmService.schema.js';

 export class PictureService {
    userid: string;
@@ -42,6 +43,7 @@ export class PictureService {
    async get(): Promise<GetResp> {
        try {
            const resp = await this.client.get<GetResp>(`picture/pictures?userid=${this.userid}&target=${this.uploaderId}`);
+            this.database.set("pictures", this.uploaderId, JSON.stringify(resp.data))
            return resp.data
        } catch (e) {
            console.log(e)
@@ -52,6 +54,15 @@ export class PictureService {
        }
    }

+    async getQuick(): Promise<Message[]> {
+        const pictures = await this.database.get("pictures", this.uploaderId)
+        if (pictures) {
+            return JSON.parse(pictures)
+        } else {
+            throw new Error("No pictures in database")
+        }
+    }
+
    /**
     * Fetches the top 10 most liked and newest pictures
     */
--- a/src/services/sessionManager.ts
+++ b/src/services/sessionManager.ts
@@ -0,0 +1,134 @@
+import {PublicUserData} from '../domain/common.schema.js';
+import {DatabaseAPI} from '../storage/database.js';
+import {KeyringAPI} from '../storage/keyring.js';
+import {KeyValueAPI} from '../storage/keyvalue.js';
+import {Session, ValidateSessionReq, ValidateSessionResp} from '../domain/sessionManager.schema.js';
+import {AxiosInstance} from "axios";
+import {getClient} from '../core/http.js';
+import {PersonalUserData} from '../domain/userService.schema.js';
+
+export class SessionManager {
+    client: AxiosInstance;
+    database: DatabaseAPI;
+    keyring: KeyringAPI;
+    KeyValue: KeyValueAPI;
+
+    constructor(database: DatabaseAPI, keyring: KeyringAPI, KeyValue: KeyValueAPI) {
+        this.database = database;
+        this.keyring = keyring;
+        this.KeyValue = KeyValue;
+        this.client = getClient(false)
+    }
+
+    /**
+     * Saves the new session to the database and the keyring
+     * @param userData
+     * @param token
+     */
+    addSession(userData: PublicUserData, token: string): void {
+        this.database.set("sessions", userData.userid, JSON.stringify(userData))
+        this.keyring.set(userData.userid, token)
+    }
+
+    /**
+     * Loads all saved sessions
+     */
+    async loadSessions(): Promise<Session[]> {
+        const tokens = await this.keyring.getAll()
+        const sessions: Session[] = []
+        for (const tokenKey of tokens) {
+            const token = await this.keyring.get(tokenKey)
+            const userData = await this.database.get("sessions", tokenKey)
+            if (userData) {
+                sessions.push({
+                    token: token,
+                    userData: JSON.parse(userData)
+                })
+            }
+        }
+
+        return sessions
+    }
+
+    /**
+     * Gets the preferred user set by the client
+     */
+    async getPreferredUser(): Promise<string> {
+        return await this.KeyValue.get("preferredUser") ?? ""
+    }
+
+    /**
+     * Sets a new preferred user
+     * @param userid
+     */
+    setPreferredUser(userid: string): void {
+        this.KeyValue.set("preferredUser", userid)
+    }
+
+    /**
+     * Loads the preferred session by the client
+     */
+    async loadPreferredSession() {
+        const sessions = await this.loadSessions()
+        let preferredUser = await this.getPreferredUser()
+        if (preferredUser == "") {
+            preferredUser = sessions[0].userData.userid
+            this.setPreferredUser(sessions[0].userData.userid)
+        }
+
+        const preferredSession = sessions.find(s => s.userData.userid == preferredUser)
+        if (preferredSession) {
+            return preferredSession
+        } else {
+            return sessions[0]
+        }
+    }
+
+    /**
+     * Validates and updates all sessions and returns with a new session list
+     * @param sessions
+     */
+    updateSessions(sessions: Session[]): Session[] {
+        sessions.forEach(async session => {
+            const index = sessions.indexOf(session)
+            if (!await this.validateSession(session.token)) {
+                this.database.delete("sessions", session.userData.userid)
+                this.keyring.delete(session.userData.userid)
+                sessions.splice(index, 1)
+            }
+
+            const updatedUserData = await this.updateUserData(session)
+            this.database.set("sessions", session.userData.userid, updatedUserData)
+            sessions[index] = updatedUserData
+        })
+
+        return sessions
+    }
+
+    private async validateSession(token: string): Promise<boolean> {
+        try {
+            const resp = await this.client.post<ValidateSessionResp>("v2/user/validateSession", <ValidateSessionReq>{
+                token: token,
+            })
+            return resp.data.validationOk
+        } catch (e) {
+            return true
+        }
+    }
+
+    private async updateUserData(session: Session): Promise<Session> {
+        const authenticatedClient = this.client.create({
+            headers: {
+                "Authorization": session.token,
+            }
+        })
+
+        try {
+            const resp = await authenticatedClient.get<PersonalUserData>(`user/byUseridPersonal?userid=${session.userData.userid}`)
+            session.userData = resp.data
+            return session
+        } catch (e) {
+            throw new Error("Session update error")
+        }
+    }
+}
--- a/src/services/textChannelService.ts
+++ b/src/services/textChannelService.ts
@@ -0,0 +1,280 @@
+import {DatabaseAPI} from '../storage/database.js';
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from '../domain/websocket.schema.js';
+import {getClient} from '../core/http.js';
+import {WebSocketHandler} from '../core/webSocketHandler.js';
+import {
+    DeleteMessagesReq,
+    EditMessageReq,
+    FinishMessageReq,
+    GetMessagePosResp, JoinWsRoomReq,
+    Message, PinMessageReq,
+    PinnedMessage, ReadMessagesReq, UnpinMessageReq
+} from '../domain/textChannelService.schema.js';
+import {NetworkInvite} from '../domain/networkService.schema.js';
+import {GenericErrorBody} from '../domain/http.schema.js';
+import {FileData, FileUploadProgressListener} from '../domain/fileUploadService.schema.js';
+import {FileUploadService} from './fileUploadService.js';
+
+export class TextChannelServiceService {
+    userid: string;
+    networkId: string;
+    categoryId: string;
+    channelId: string;
+    token: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, networkId: string, categoryId: string, channelId: string, database: DatabaseAPI, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.networkId = networkId;
+        this.categoryId = categoryId;
+        this.channelId = channelId;
+        this.database = database;
+        this.token = token;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: channelId,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    /**
+     * Fetches all messages in the chat
+     * @param from
+     */
+    async get(from: number = 0): Promise<Message[]> {
+        try {
+            const resp = await this.client.get<Message[]>(`network/channel/messages?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}&from=${from}`);
+            if (from == 0) {
+                this.database.set("networkmessages", this.channelId, JSON.stringify(resp.data))
+            }
+            console.log(resp.data, "ASD")
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async getQuick(): Promise<Message[]> {
+        const messages = await this.database.get("networkmessages", this.channelId)
+        if (messages) {
+            return JSON.parse(messages)
+        } else {
+            throw new Error("No messages in database")
+        }
+    }
+
+    /**
+     * Fetches the position of the specified message which can be used in get() to fetch an old message with it's surrounding messages
+     * @param messageId
+     */
+    async getMessagePos(messageId: string): Promise<number> {
+        try {
+            const resp = await this.client.get<GetMessagePosResp>(`network/channel/getMessagePosition?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}&messageId=${messageId}`);
+            return resp.data.messagePos
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets all messages pinned in the chat
+     */
+    async getPinnedMessages(): Promise<PinnedMessage[]> {
+        try {
+            const resp = await this.client.get<PinnedMessage[]>(`network/channel/pinnedMessages?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}`);
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Edits the specified message
+     * @param messageId
+     * @param newMessage
+     */
+    async editMessage(messageId: string, newMessage: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/editMessage", <EditMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                message: newMessage
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Sends a new message to the chat
+     * @param message
+     * @param replyTo
+     * @param replyToMessage
+     * @param attachments
+     * @param progressListener
+     */
+    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null, progressListener: FileUploadProgressListener | null = null): Promise<Message> {
+        let uploadId = ""
+        if (attachments) {
+            const uploader = new FileUploadService(this.token)
+            uploadId = await uploader.uploadFiles(this.channelId, this.userid, attachments, progressListener!)
+        }
+        try {
+            const resp = await this.client.post<Message>("network/channel/finishMessage", <FinishMessageReq>{
+                message: message,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                replyTo: replyTo,
+                replyToMessage: replyToMessage,
+                userid: this.userid,
+                uploadId: uploadId,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Reads all messages sent to you in the chat
+     */
+    async readMessages(): Promise<void> {
+        try {
+            await this.client.patch("network/channel/readMessages", <ReadMessagesReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Pins the specified message
+     * @param messageId
+     * @param message
+     */
+    async pinMessage(messageId: string, message: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/pinMessage", <PinMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                message: message
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Unpins the specified message
+     * @param messageId
+     */
+    async unpinMessage(messageId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/unpinMessage", <UnpinMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes the message(s)
+     * @param messageIds
+     */
+    async deleteMessages(messageIds: string[]): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/deleteMessages", <DeleteMessagesReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                messageIds: messageIds
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Joins the WebSocket room to start receiving realtime messages
+     */
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/joinWebSocketRoom", <JoinWsRoomReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                connId: WebSocketHandler.getInstance().connId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/services/userService.test.ts
+++ b/src/services/userService.test.ts
@@ -0,0 +1,12 @@
+import {describe, expect, it} from "vitest";
+import {UserService} from './userService.js';
+import {DatabaseMock} from '../mocks/storage/database.js';
+
+describe("UserService", () => {
+    const service = new UserService("", "", new DatabaseMock())
+
+    it('should get all sessions', async () => {
+        const sessions = await service.getSessions()
+        expect(sessions[0].token).toBe("sessionToken")
+    });
+})
--- a/src/services/userService.ts
+++ b/src/services/userService.ts
@@ -0,0 +1,253 @@
+import {DatabaseAPI} from '../storage/database.js';
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from '../domain/websocket.schema.js';
+import {getClient} from '../core/http.js';
+import {WebSocketHandler} from '../core/webSocketHandler.js';
+import {DeleteCategoryReq} from '../domain/networkService.schema.js';
+import {GenericErrorBody} from '../domain/http.schema.js';
+import {
+    ChangeDisplayNameReq,
+    ChangeEmailReq,
+    ChangePasswordReq, ChangePhoneReq,
+    ChangeUsernameReq, CurrNewCodeTestingResp, DeleteReq, GetSessionsReq, GIF, RegisterFCMTokenReq, Session,
+    ToggleGifSaveReq, UploadNewPfpCdnReq, UploadNewPfpCdnResp,
+    UploadNewPfpReq, VerifyMailChangeReq, VerifyPhoneChange
+} from '../domain/userService.schema.js';
+import {RGB} from '../domain/common.schema.js';
+import {OtpPleCodeSendTestingResp} from '../domain/authService.schema.js';
+
+export class UserService {
+    userid: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+    cdnClient: AxiosInstance
+
+    constructor(userid: string, token: string, database: DatabaseAPI) {
+        this.userid = userid;
+        this.database = database;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+            }
+        })
+        this.cdnClient = getClient(true).create({
+            headers: {
+                "Authorization": token,
+            }
+        })
+    }
+
+    async changeUsername(username: string): Promise<void> {
+        try {
+            await this.client.patch("user/changeUsername", <ChangeUsernameReq>{
+                userid: this.userid,
+                newUsername: username,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async changeDisplayName(displayName: string): Promise<void> {
+        try {
+            await this.client.patch("user/changeDisplayName", <ChangeDisplayNameReq>{
+                userid: this.userid,
+                newDisplayName: displayName
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async changePassword(newPassword: string, currentPassword: string): Promise<void> {
+        try {
+            await this.client.patch("user/changePassword", <ChangePasswordReq>{
+                userid: this.userid,
+                currentPassword: currentPassword,
+                newPassword: newPassword,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async changeEmail(newMail: string, currentPassword: string): Promise<void|CurrNewCodeTestingResp> {
+        try {
+            const resp = await this.client.patch<CurrNewCodeTestingResp>("user/changeEmail", <ChangeEmailReq>{
+                userid: this.userid,
+                currentPassword: currentPassword,
+                newMail: newMail,
+            });
+            if (resp.data.codeCurr != null) {
+                return resp.data
+            } else {
+                return
+            }
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async uploadNewPfp(pfpId: string): Promise<void> {
+        try {
+            await this.client.patch("user/uploadNewPfp", <UploadNewPfpReq>{
+                userid: this.userid,
+                pfpId: pfpId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async uploadNewPfpCdn(image: string | null, monogramLetter: string | null, monogramColors: RGB): Promise<string> {
+        try {
+            const resp = await this.cdnClient.post<UploadNewPfpCdnResp>("pfp", <UploadNewPfpCdnReq>{
+                userid: this.userid,
+                data: image,
+                monogramColors: JSON.stringify(monogramColors),
+                isImage: image !== null,
+                monogramLetter: monogramLetter,
+            });
+            console.log(resp.data.pfpId, "PFPID")
+            return resp.data.pfpId
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async verifyEmailChange(vCodeCurrent: number, vCodeNew: number, newAddress: string): Promise<void> {
+        try {
+            await this.client.patch("user/verifyMailChange", <VerifyMailChangeReq>{
+                userid: this.userid,
+                newAddress: newAddress,
+                vCodeCurrent: vCodeCurrent,
+                vCodeNew: vCodeNew,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async delete(password: string): Promise<void> {
+        try {
+            await this.client.post("user/deleteAccount", <DeleteReq>{
+                userid: this.userid,
+                password: password
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async registerFirebaseToken(fcmToken: string): Promise<void> {
+        try {
+            await this.client.post("user/registerFcmToken", <RegisterFCMTokenReq>{
+                userid: this.userid,
+                token: fcmToken,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async getSessions(): Promise<Session[]> {
+        try {
+            const resp = await this.client.post<Session[]>("user/getSessions", <GetSessionsReq>{
+                userid: this.userid,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async toggleGIFSave(url: string): Promise<GIF> {
+        try {
+            const resp = await this.client.patch<GIF>("user/toggleGIFSave", <ToggleGifSaveReq>{
+                userid: this.userid,
+                url: url
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async changePhoneNumber(currentPassword: string, newPhone: string): Promise<CurrNewCodeTestingResp|void> {
+        try {
+            const resp = await this.client.patch<CurrNewCodeTestingResp>("user/changePhone", <ChangePhoneReq>{
+                userid: this.userid,
+                newPhone: newPhone,
+                currentPassword: currentPassword,
+            });
+            if (resp.data.codeCurr != null) {
+                return resp.data
+            } else {
+                return
+            }
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async verifyPhoneNumberChange(newPhone: string, vCodeCurrent: number, vCodeNew: number): Promise<void> {
+        try {
+            const resp = await this.client.patch("user/verifyPhoneChange", <VerifyPhoneChange>{
+                userid: this.userid,
+                newPhone: newPhone,
+                vCodeCurrent: vCodeCurrent,
+                vCodeNew: vCodeNew,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}
--- a/src/storage/database.ts
+++ b/src/storage/database.ts
@@ -1,6 +1,6 @@
 export interface DatabaseAPI {
    set(collection: string, key: string, value: any): void;
-    get(collection: string, key: string): string;
+    get(collection: string, key: string): Promise<string>;
    delete(collection: string, key: string): void;
    flush(): void;
 }
--- a/src/storage/keyring.ts
+++ b/src/storage/keyring.ts
@@ -1,6 +1,6 @@
 export interface KeyringAPI {
    set(key: string, value: any): void;
-    get(key: string): string;
+    get(key: string): Promise<string>;
+    getAll(): Promise<string[]>;
    delete(key: string): void;
-    flush(): void;
 }
--- a/src/storage/keyvalue.ts
+++ b/src/storage/keyvalue.ts
@@ -0,0 +1,6 @@
+export interface KeyValueAPI {
+    set(key: string, value: any): void;
+    get(key: string): Promise<string>;
+    delete(key: string): void;
+    flush(): void;
+}
--- a/src/vitest.setup.unit.ts
+++ b/src/vitest.setup.unit.ts
@@ -1,5 +1,5 @@
 import {beforeAll, afterEach, afterAll, vi} from 'vitest';
-import {mockServer} from "./mocks/node";
+import {mockServer} from './mocks/node.js';

 beforeAll(() => mockServer.listen({onUnhandledRequest: 'error'}));
 afterEach(() => mockServer.resetHandlers());
--- a/tests/authService.test.ts
+++ b/tests/authService.test.ts
@@ -1,6 +1,6 @@
 import {describe, expect, it} from "vitest";
-import {AuthService} from "../src/services/authService";
-import {VerificationTypeEmail} from "../src/domain/authService.schema";
+import {AuthService} from '../src/services/authService.js';
+import {VerificationTypeEmail} from '../src/domain/authService.schema.js';

 describe("AuthService", () => {
    it("should return authMethods", async () => {
--- a/tests/broadcastChannelService.test.ts
+++ b/tests/broadcastChannelService.test.ts
@@ -0,0 +1,29 @@
+import {describe, expect, it} from "vitest";
+import {BroadcastChannelService} from '../src/services/broadcastChannelService.js';
+
+const BRC_CHAN_SERVICE_TESTING_NETWORK_ID = "000000000000000000000000"
+const BRC_CHAN_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+const BRC_CHAN_SERVICE_TESTING_CHANNEL_ID = "333333333333333333333333"
+const BRC_CHAN_SERVICE_TESTING_TOKEN = "testingToken"
+const BRC_CHAN_SERVICE_TESTING_CATEGORY_ID = "111111111111111111111111"
+
+describe("BroadcastChannelService Integration Testing", () => {
+    const service = new BroadcastChannelService(
+        BRC_CHAN_SERVICE_TESTING_TOKEN,
+        BRC_CHAN_SERVICE_TESTING_USER_ID,
+        BRC_CHAN_SERVICE_TESTING_NETWORK_ID,
+        BRC_CHAN_SERVICE_TESTING_CATEGORY_ID,
+        BRC_CHAN_SERVICE_TESTING_CHANNEL_ID,
+        (action, data) => {}
+    )
+
+    it('should create a new server and fetch it', async () => {
+        await service.createServer()
+        const registry = await service.getData()
+        expect(registry.status).toBe("idling")
+    });
+
+    it('should join ws room', async () => {
+        await service.joinWebSocketRoom()
+    });
+})
--- a/tests/chatsService.test.ts
+++ b/tests/chatsService.test.ts
@@ -1,6 +1,6 @@
 import {describe, expect, it} from "vitest";
-import {DatabaseMock} from "../src/mocks/storage/database";
-import {ChatService} from "../src/services/chatService";
+import {DatabaseMock} from '../src/mocks/storage/database.js';
+import {ChatService} from '../src/services/chatService.js';

 describe("ChatService Integration Testing", () => {
    const CHAT_SERVICE_TESTING_USER_ID = "000000000000000000000000"
--- a/tests/dmService.test.ts
+++ b/tests/dmService.test.ts
@@ -0,0 +1,61 @@
+import {describe, expect, it} from "vitest";
+import {DMService} from '../src/services/dmService.js';
+import {ChatService} from '../src/services/chatService.js';
+import {DatabaseMock} from '../src/mocks/storage/database.js';
+import {faker} from "@faker-js/faker/locale/en";
+
+describe("DmService Integration Testing", () => {
+    const DM_SERVICE_TESTING_CHAT_ID = "000000000000000000000000"
+    const DM_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+    const DM_SERVICE_TESTING_MESSAGE_ID = "111111111111111111111111"
+    const DM_SERVICE_TESTING_TOKEN = "testingToken"
+
+    const service = new DMService(
+        DM_SERVICE_TESTING_USER_ID,
+        DM_SERVICE_TESTING_TOKEN,
+        DM_SERVICE_TESTING_CHAT_ID,
+        new DatabaseMock(),
+        () => {}
+    )
+
+    it('should get messages', async () => {
+        const messages = await service.get()
+        expect(messages[0].message).toBe("This is a message")
+        expect(messages[0].isEdited).toBeTruthy()
+    });
+
+    it('should get message position', async () => {
+        const pos = await service.getMessagePos(DM_SERVICE_TESTING_MESSAGE_ID)
+        expect(pos).toBe(0)
+    });
+
+    it('should edit message', async () => {
+        const newMessage = faker.lorem.paragraph()
+        await service.editMessage(DM_SERVICE_TESTING_MESSAGE_ID, newMessage)
+        const messages = await service.get()
+        expect(messages[0].message).toBe(newMessage)
+    });
+
+    it('should send a message', async () => {
+        const message = faker.lorem.paragraph()
+        const newMessage = await service.sendMessage(message)
+        expect(newMessage.message).toBe(message)
+    });
+
+    it('should read messages', async () => {
+        await service.readMessages()
+    });
+
+    it('should pin and unpin messages', async () => {
+        let pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+
+        await service.pinMessage(DM_SERVICE_TESTING_MESSAGE_ID, "message")
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(1)
+
+        await service.unpinMessage(DM_SERVICE_TESTING_MESSAGE_ID)
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+    });
+})
--- a/tests/fileUploadService.test.ts
+++ b/tests/fileUploadService.test.ts
@@ -1,9 +1,10 @@
 import {describe, it} from "vitest";
-import {FileUploadService} from "../src/services/fileUploadService";
-import {environment, SDKConfig} from "../src/core/environment";
-import {getClient} from "../src/core/http";
-import {FileData} from "../src/domain/fileUploadService.schema";
+import {FileUploadService} from '../src/services/fileUploadService.js';
+import {environment, SDKConfig} from '../src/core/environment.js';
+import {getClient} from '../src/core/http.js';
+import {FileData} from '../src/domain/fileUploadService.schema.js';
 import axios from "axios";
+import {v4 as uuidv4} from 'uuid';

 describe("FileUploadService Integration Testing", () => {
    const FILE_UPL_SERVICE_TESTING_USER_ID = "000000000000000000000000"
@@ -21,12 +22,16 @@ describe("FileUploadService Integration Testing", () => {
            FILE_UPL_SERVICE_TESTING_USER_ID,
            [
                {
+                    fileId: uuidv4(),
                    name: "filename",
                    type: "image",
                    extension: "jpeg",
                    data: new File([response.data], "filename", { type: "image/jpeg" })
                }
-            ]
+            ],
+            {
+                fileProgressUpdate: () => {},
+            }
        )
    });
 })
--- a/tests/networkService.test.ts
+++ b/tests/networkService.test.ts
@@ -1,12 +1,12 @@
 import {describe, expect, it} from "vitest";
-import {NetworkService} from "../src/services/networkService";
-import {DatabaseMock} from "../src/mocks/storage/database";
-import {environment, SDKConfig} from "../src/core/environment";
-import {getClient} from "../src/core/http";
+import {NetworkService} from '../src/services/networkService.js';
+import {DatabaseMock} from '../src/mocks/storage/database.js';
+import {environment, SDKConfig} from '../src/core/environment.js';
+import {getClient} from '../src/core/http.js';
 import {faker} from "@faker-js/faker/locale/en";
-import {AuthService} from "../src/services/authService";
-import {RGB} from "../src/domain/common.schema";
-import {NetworkPermissions, PermissionUpdate} from "../src/domain/networkService.schema";
+import {AuthService} from '../src/services/authService.js';
+import {RGB} from '../src/domain/common.schema.js';
+import {NetworkPermissions, PermissionUpdate} from '../src/domain/networkService.schema.js';

 const NETWORK_SERVICE_TESTING_NETWORK_ID = "000000000000000000000000"
 const NETWORK_SERVICE_TESTING_USER_ID = "000000000000000000000000"
@@ -56,12 +56,6 @@ describe("NetworkService Integration Testing", () => {
        expect(category.name).toBe(catName)
    });

-    it('should delete category', async () => {
-        await service.deleteCategory(NETWORK_SERVICE_TESTING_CATEGORY_ID)
-        const networks = await service.get()
-        expect(networks[0].categories.length).toBe(0)
-    });
-
    it('should move category', async () => {
        await service.createCategory("Test name", "Test desc")
        await service.moveCategory(0, 1)
@@ -74,7 +68,7 @@ describe("NetworkService Integration Testing", () => {
    });

    it('should create rank', async () => {
-        const rankName = faker.internet.displayName()
+        const rankName = faker.internet.displayName().substring(0, 10)
        const rank = await service.createRank(rankName, <RGB>{r: 0, g: 0, b: 0}, null)
        expect(rank.name).toBe(rankName)
    });
--- a/tests/pictureService.test.ts
+++ b/tests/pictureService.test.ts
@@ -1,9 +1,9 @@
 import {describe, expect, it} from "vitest";
-import {environment, SDKConfig} from "../src/core/environment";
-import {NetworkService} from "../src/services/networkService";
-import {DatabaseMock} from "../src/mocks/storage/database";
-import {getClient} from "../src/core/http";
-import {PictureService} from "../src/services/pictureService";
+import {environment, SDKConfig} from '../src/core/environment.js';
+import {NetworkService} from '../src/services/networkService.js';
+import {DatabaseMock} from '../src/mocks/storage/database.js';
+import {getClient} from '../src/core/http.js';
+import {PictureService} from '../src/services/pictureService.js';
 import {faker} from "@faker-js/faker/locale/en";

 const PICTURE_SERVICE_TESTING_TOKEN = "testingToken"
@@ -24,7 +24,7 @@ describe("PictureService Integration Test", () => {
    });

    it('should create an album', async () => {
-        const albumName = faker.internet.displayName()
+        const albumName = faker.internet.displayName().substring(0, 10)
        await service.createAlbum(albumName)
        const uploads = await service.get()
        expect(uploads.pictures[1].name).toBe(albumName)
--- a/tests/textChannelService.test.ts
+++ b/tests/textChannelService.test.ts
@@ -0,0 +1,66 @@
+import {describe, expect, it} from "vitest";
+import {DMService} from '../src/services/dmService.js';
+import {ChatService} from '../src/services/chatService.js';
+import {DatabaseMock} from '../src/mocks/storage/database.js';
+import {faker} from "@faker-js/faker/locale/en";
+import {TextChannelServiceService} from '../src/services/textChannelService.js';
+
+describe("DmService Integration Testing", () => {
+    const TXT_CHAN_SERVICE_TESTING_CHANNEL_ID = "222222222222222222222222"
+    const TXT_CHAN_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+    const TXT_CHAN_SERVICE_TESTING_MESSAGE_ID = "111111111111111111111111"
+    const TXT_CHAN_SERVICE_TESTING_TOKEN = "testingToken"
+    const NETWORK_SERVICE_TESTING_NETWORK_ID = "000000000000000000000000"
+    const NETWORK_SERVICE_TESTING_CATEGORY_ID = "111111111111111111111111"
+
+    const service = new TextChannelServiceService(
+        TXT_CHAN_SERVICE_TESTING_USER_ID,
+        TXT_CHAN_SERVICE_TESTING_TOKEN,
+        NETWORK_SERVICE_TESTING_NETWORK_ID,
+        NETWORK_SERVICE_TESTING_CATEGORY_ID,
+        TXT_CHAN_SERVICE_TESTING_CHANNEL_ID,
+        new DatabaseMock(),
+        () => {}
+    )
+
+    it('should get messages', async () => {
+        const messages = await service.get()
+        expect(messages[0].message).toBe("This is a message")
+        expect(messages[0].isEdited).toBeTruthy()
+    });
+
+    it('should get message position', async () => {
+        const pos = await service.getMessagePos(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID)
+        expect(pos).toBe(0)
+    });
+
+    it('should edit message', async () => {
+        const newMessage = faker.lorem.paragraph()
+        await service.editMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID, newMessage)
+        const messages = await service.get()
+        expect(messages[0].message).toBe(newMessage)
+    });
+
+    it('should send a message', async () => {
+        const message = faker.lorem.paragraph()
+        const newMessage = await service.sendMessage(message)
+        expect(newMessage.message).toBe(message)
+    });
+
+    it('should read messages', async () => {
+        await service.readMessages()
+    });
+
+    it('should pin and unpin messages', async () => {
+        let pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+
+        await service.pinMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID, "message")
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(1)
+
+        await service.unpinMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID)
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+    });
+})
--- a/tests/userService.test.ts
+++ b/tests/userService.test.ts
@@ -0,0 +1,50 @@
+import {describe, expect, it} from "vitest";
+import {UserService} from '../src/services/userService.js';
+import {DatabaseMock} from '../src/mocks/storage/database.js';
+import {RGB} from '../src/domain/common.schema.js'
+
+const USER_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+const USER_SERVICE_TESTING_TOKEN = "testingToken"
+
+
+describe("UserService Integration Testing", () => {
+    const service = new UserService(USER_SERVICE_TESTING_USER_ID, USER_SERVICE_TESTING_TOKEN, new DatabaseMock())
+    
+    it('should not throw on username change', async () => {
+        await service.changeUsername("bob2")
+    });
+
+    it('should not throw on displayName change', async () => {
+        await service.changeDisplayName("New Display Name")
+    });
+
+    it('should set new password', async () => {
+        await service.changePassword("newPasswd", "") // The filler user doesn't have a password set yet
+    });
+
+    it('should set new e-mail', async () => {
+        const code = await service.changeEmail("bob2@example.com", "")
+        expect(code).not.toBeNull()
+        if (code != null) {
+            await service.verifyEmailChange(code.codeCurr??0, code.codeNew??0, "bob2@example.com")
+        }
+    });
+
+    it('should upload a new pfp', async () => {
+        const pfpId = await service.uploadNewPfpCdn(null, "A", <RGB>{r: 255, g: 255, b: 255})
+        await service.uploadNewPfp(pfpId)
+    });
+
+    it('should get sessions', async () => {
+        const sessions = await service.getSessions()
+        expect(sessions[0].token).toBe(USER_SERVICE_TESTING_TOKEN)
+    });
+
+    it('should set new phone', async () => {
+        const code = await service.changePhoneNumber("", "+36201234567")
+        expect(code).not.toBeNull()
+        if (code != null) {
+            await service.verifyPhoneNumberChange("+36201234567", code.codeCurr??0, code.codeNew??0)
+        }
+    });
+})
--- a/tests/vitest.setup.integration.ts
+++ b/tests/vitest.setup.integration.ts
@@ -1,6 +1,6 @@
 import {beforeAll, beforeEach} from 'vitest';
-import {environment, SDKConfig} from "../src/core/environment";
-import {getClient} from "../src/core/http";
+import {environment, SDKConfig} from '../src/core/environment.js';
+import {getClient} from '../src/core/http.js';

 beforeEach(async () => {
    await getClient(false).post("v2/reset")
--- a/tests/webSocketHandler.test.ts
+++ b/tests/webSocketHandler.test.ts
@@ -1,5 +1,5 @@
 import {describe, it} from "vitest";
-import {WebSocketHandler} from "../src/core/webSocketHandler";
+import {WebSocketHandler} from '../src/core/webSocketHandler.js';

 const WEBSOCKET_HANDLER_TESTING_USER_ID = "000000000000000000000000"
 const WEBSOCKET_HANDLER_TESTING_USER_TOKEN = "testingToken"
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,12 +1,15 @@
 {
  "compilerOptions": {
    "target": "es2016",
-    "module": "commonjs",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
    "strict": true,
    "skipLibCheck": true,
-    "outDir": "dist"
+    "outDir": "dist",
+    "verbatimModuleSyntax": false,
  },
  "include": ["src"]
 }
Author	SHA1	Message	Date
chatenium	77e032fdb2	HotFix All checks were successful Publish to NPM / build-and-publish (release) Successful in 31s Details Setup testing environment and test the code / build (push) Successful in 59s Details	2026-04-09 12:04:42 +02:00
chatenium	96a5e5896b	HotFix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m13s Details Publish to NPM / build-and-publish (release) Successful in 33s Details	2026-04-09 11:56:40 +02:00
chatenium	14fe7ef41d	HotFix	2026-04-09 11:56:29 +02:00
chatenium	d04bd6a437	HotFix All checks were successful Setup testing environment and test the code / build (push) Successful in 57s Details Publish to NPM / build-and-publish (release) Successful in 33s Details	2026-04-09 11:18:47 +02:00
chatenium	0e553767b6	HotFix Some checks failed Publish to NPM / build-and-publish (release) Has been cancelled Details Setup testing environment and test the code / build (push) Failing after 1m1s Details	2026-04-09 11:16:45 +02:00
chatenium	b7af5497a4	Fix DM WebSocket Some checks failed Setup testing environment and test the code / build (push) Failing after 1m22s Details Publish to NPM / build-and-publish (release) Successful in 30s Details	2026-04-09 11:12:41 +02:00
chatenium	1cd629e3c1	loadSessions hotfix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m20s Details Publish to NPM / build-and-publish (release) Successful in 27s Details	2026-04-08 19:18:06 +02:00
chatenium	7d50692ece	Make storage async All checks were successful Setup testing environment and test the code / build (push) Successful in 1m4s Details Publish to NPM / build-and-publish (release) Successful in 41s Details	2026-04-08 18:10:46 +02:00
chatenium	d7422efcf0	Quick-fix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m2s Details	2026-04-08 16:56:09 +02:00
chatenium	1ccf534e04	Quick-fix Some checks failed Setup testing environment and test the code / build (push) Successful in 1m1s Details Publish to NPM / build-and-publish (release) Failing after 29s Details	2026-04-08 16:48:11 +02:00
chatenium	7ba341203d	Quick-fix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m6s Details Publish to NPM / build-and-publish (release) Successful in 36s Details	2026-04-08 16:44:41 +02:00
chatenium	54d466fb27	Quick-fix All checks were successful Publish to NPM / build-and-publish (release) Successful in 34s Details Setup testing environment and test the code / build (push) Successful in 1m30s Details	2026-04-08 16:37:32 +02:00
chatenium	07d30f7e83	Quick-fix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m28s Details	2026-04-08 14:22:58 +02:00
Almsss	cd806b7d17	Update package.json Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:59:00 +02:00
Almsss	7daf542961	Update .gitea/workflows/publish.yml Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:55:29 +02:00
Almsss	f911224847	Update .gitea/workflows/publish.yml Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:53:45 +02:00
chatenium	c8d2de9f9d	Merge remote-tracking branch 'origin/main' Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:51:47 +02:00
chatenium	f8de78f3ab	Type fixes	2026-04-08 13:51:43 +02:00
Almsss	e07114b1c0	Update .gitea/workflows/publish.yml Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:50:17 +02:00
Almsss	e8c6b9c920	Update .gitea/workflows/publish.yml Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:47:51 +02:00
Almsss	0a97a2cc48	Add .gitea/workflows/publish Some checks failed Setup testing environment and test the code / build (push) Has been cancelled Details	2026-04-08 13:47:38 +02:00
chatenium	0b38b002df	Implemented SessionManager and TextChannelService + several improvements and fixes All checks were successful Setup testing environment and test the code / build (push) Successful in 1m13s Details	2026-04-08 13:21:11 +02:00
chatenium	a9322e3454	Implemented BroadcastChannelService and FileTransferService All checks were successful Setup testing environment and test the code / build (push) Successful in 1m17s Details	2026-04-08 08:46:16 +02:00
chatenium	e6798b4be8	Mock database hotfix All checks were successful Setup testing environment and test the code / build (push) Successful in 1m6s Details	2026-04-07 11:37:29 +02:00
chatenium	55e4aad0a9	Merge remote-tracking branch 'origin/main' Some checks failed Setup testing environment and test the code / build (push) Failing after 1m24s Details	2026-04-07 11:19:42 +02:00
chatenium	4f96b1d687	Added caching and implemented UserService	2026-04-07 11:19:38 +02:00
chatenium	aa451e4786	Fix grammar	2026-04-07 10:15:05 +02:00
Almsss	e9eb95e9b7	Add LICENSE All checks were successful Setup testing environment and test the code / build (push) Successful in 1m29s Details	2026-04-07 10:13:30 +02:00
chatenium	f787ec56a8	Merge remote-tracking branch 'origin/main' All checks were successful Setup testing environment and test the code / build (push) Successful in 1m17s Details	2026-04-06 08:00:21 +02:00
chatenium	91bb2a5d9c	Implemented DMService	2026-04-06 08:00:16 +02:00