Breaking changes:

'Gift': changed from class to enum, so now you can handle
incoming gifts in switch

`Events`
- new:
     onGiftComboFinished
- Removed:
      onGiftBrodcast
- Rename:
     onGiftMessage -> onGift
     onRoomPinMessage -> onRoomPin
     onRoomMessage -> onRoom
     onLinkMessage -> onLink
     onBarrageMessage -> onBarrage
     onPollMessage -> onPoll
     onShopMessage -> onShop
     onDetectMessage -> onDetect

`GiftManager`
   added:
      registerGift
      findById
      findByName
      getGifts
   removed:
      getActiveGifts

API/src/main/java/io/github/jwdeveloper/tiktok/live/builder/EventBuilder.java

@@ -20,7 +20,7 @@
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-package io.github.jwdeveloper.tiktok.live.events;
+package io.github.jwdeveloper.tiktok.live.builder;
 
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.*;
@@ -37,59 +37,57 @@ import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketRespons
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketUnhandledMessageEvent;
 
 
-public interface TikTokEventBuilder<T> {
+public interface EventBuilder<T> {
 
-    T onRoom(TikTokEventConsumer<TikTokRoomEvent> event);
+    T onRoom(EventConsumer<TikTokRoomEvent> event);
 
-    T onRoomUserInfo(TikTokEventConsumer<TikTokRoomUserInfoEvent> event);
+    T onRoomUserInfo(EventConsumer<TikTokRoomUserInfoEvent> event);
 
-    T onComment(TikTokEventConsumer<TikTokCommentEvent> event);
+    T onComment(EventConsumer<TikTokCommentEvent> event);
 
 
-    T onWebsocketMessage(TikTokEventConsumer<TikTokWebsocketMessageEvent> event);
+    T onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event);
 
-    T onWebsocketResponse(TikTokEventConsumer<TikTokWebsocketResponseEvent> event);
+    T onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event);
 
-    T onWebsocketUnhandledMessage(TikTokEventConsumer<TikTokWebsocketUnhandledMessageEvent> event);
+    T onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event);
 
 
-    T onGiftCombo(TikTokEventConsumer<TikTokGiftComboFinishedEvent> event);
+    T onGiftCombo(EventConsumer<TikTokGiftComboFinishedEvent> event);
 
-    T onGift(TikTokEventConsumer<TikTokGiftEvent> event);
+    T onGift(EventConsumer<TikTokGiftEvent> event);
 
-    T onQuestion(TikTokEventConsumer<TikTokQuestionEvent> event);
+    T onQuestion(EventConsumer<TikTokQuestionEvent> event);
 
-    T onSubscribe(TikTokEventConsumer<TikTokSubscribeEvent> event);
+    T onSubscribe(EventConsumer<TikTokSubscribeEvent> event);
 
-    T onFollow(TikTokEventConsumer<TikTokFollowEvent> event);
+    T onFollow(EventConsumer<TikTokFollowEvent> event);
 
-    T onLike(TikTokEventConsumer<TikTokLikeEvent> event);
+    T onLike(EventConsumer<TikTokLikeEvent> event);
 
-    T onEmote(TikTokEventConsumer<TikTokEmoteEvent> event);
+    T onEmote(EventConsumer<TikTokEmoteEvent> event);
 
-    T onJoin(TikTokEventConsumer<TikTokJoinEvent> event);
+    T onJoin(EventConsumer<TikTokJoinEvent> event);
 
-    T onShare(TikTokEventConsumer<TikTokShareEvent> event);
+    T onShare(EventConsumer<TikTokShareEvent> event);
+    T onUnhandledSocial(EventConsumer<TikTokUnhandledSocialEvent> event);
 
-    T onUnhandledSocial(TikTokEventConsumer<TikTokUnhandledSocialEvent> event);
+    T onLivePaused(EventConsumer<TikTokLivePausedEvent> event);
+
+    T onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event);
+
+    T onConnected(EventConsumer<TikTokConnectedEvent> event);
+
+    T onReconnecting(EventConsumer<TikTokReconnectingEvent> event);
+
+    T onDisconnected(EventConsumer<TikTokDisconnectedEvent> event);
+
+    T onError(EventConsumer<TikTokErrorEvent> event);
+
+    T onEvent(EventConsumer<TikTokEvent> event);
 
 
-    T onLivePaused(TikTokEventConsumer<TikTokLivePausedEvent> event);
+    // TODO Figure out how those events works
-
-    T onLiveEnded(TikTokEventConsumer<TikTokLiveEndedEvent> event);
-
-    T onConnected(TikTokEventConsumer<TikTokConnectedEvent> event);
-
-    T onReconnecting(TikTokEventConsumer<TikTokReconnectingEvent> event);
-
-    T onDisconnected(TikTokEventConsumer<TikTokDisconnectedEvent> event);
-
-    T onError(TikTokEventConsumer<TikTokErrorEvent> event);
-
-    T onEvent(TikTokEventConsumer<TikTokEvent> event);
-
-
-    // TODO implement later
     //T onLinkMicFanTicket(TikTokEventConsumer<TikTokLinkMicFanTicketEvent> event);
 
     //T onEnvelope(TikTokEventConsumer<TikTokEnvelopeEvent> event);
@@ -102,8 +100,6 @@ public interface TikTokEventBuilder<T> {
 
     //T onCaption(TikTokEventConsumer<TikTokCaptionEvent> event);
 
-
-
     //T onRoomPin(TikTokEventConsumer<TikTokRoomPinEvent> event);
 
     //T onBarrage(TikTokEventConsumer<TikTokBarrageEvent> event);

API/src/main/java/io/github/jwdeveloper/tiktok/live/builder/EventConsumer.java

@@ -20,12 +20,12 @@
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-package io.github.jwdeveloper.tiktok.live.events;
+package io.github.jwdeveloper.tiktok.live.builder;
 
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 
-public interface TikTokEventConsumer<T extends TikTokEvent>
+public interface EventConsumer<T extends TikTokEvent>
 {
      void onEvent(LiveClient liveClient, T event);
 }

API/src/main/java/io/github/jwdeveloper/tiktok/live/builder/LiveClientBuilder.java

@@ -0,0 +1,21 @@
+package io.github.jwdeveloper.tiktok.live.builder;
+
+import io.github.jwdeveloper.tiktok.ClientSettings;
+import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+
+public interface LiveClientBuilder extends EventBuilder<LiveClientBuilder>
+{
+
+    LiveClientBuilder configure(Consumer<ClientSettings> consumer);
+
+    LiveClientBuilder addListener(TikTokEventListener listener);
+
+    LiveClient build();
+    LiveClient buildAndConnect();
+
+    CompletableFuture<LiveClient> buildAndConnectAsync();
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLive.java

@@ -23,11 +23,12 @@
 package io.github.jwdeveloper.tiktok;
 
 
+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
 
 public class TikTokLive
 {
-    public static TikTokLiveClientBuilder newClient(String userName)
+    public static LiveClientBuilder newClient(String hostName)
     {
-        return new TikTokLiveClientBuilder(userName);
+        return new TikTokLiveClientBuilder(hostName);
     }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveClientBuilder.java

@@ -23,8 +23,8 @@
 package io.github.jwdeveloper.tiktok;
 
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventBuilder;
+import io.github.jwdeveloper.tiktok.live.builder.EventBuilder;
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventConsumer;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.data.events.TikTokConnectedEvent;
 import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
@@ -53,6 +53,7 @@ import io.github.jwdeveloper.tiktok.http.TikTokHttpRequestFactory;
 import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
 import io.github.jwdeveloper.tiktok.listener.TikTokListenersManager;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
 import io.github.jwdeveloper.tiktok.utils.ConsoleColors;
 import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketClient;
 
@@ -63,7 +64,9 @@ import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
 import java.util.logging.*;
 
-public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveClientBuilder> {
+public class TikTokLiveClientBuilder implements LiveClientBuilder
+{
+
     protected final ClientSettings clientSettings;
     protected final Logger logger;
     protected final TikTokEventObserver tikTokEventHandler;
@@ -172,249 +175,249 @@ public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveCli
     }
 
     public TikTokLiveClientBuilder onUnhandledSocial(
-            TikTokEventConsumer<TikTokUnhandledSocialEvent> event) {
+            EventConsumer<TikTokUnhandledSocialEvent> event) {
         tikTokEventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicFanTicket(
-            TikTokEventConsumer<TikTokLinkMicFanTicketEvent> event) {
+            EventConsumer<TikTokLinkMicFanTicketEvent> event) {
         tikTokEventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onEnvelope(TikTokEventConsumer<TikTokEnvelopeEvent> event) {
+    public TikTokLiveClientBuilder onEnvelope(EventConsumer<TikTokEnvelopeEvent> event) {
         tikTokEventHandler.subscribe(TikTokEnvelopeEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onShop(TikTokEventConsumer<TikTokShopEvent> event) {
+    public TikTokLiveClientBuilder onShop(EventConsumer<TikTokShopEvent> event) {
         tikTokEventHandler.subscribe(TikTokShopEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onDetect(
-            TikTokEventConsumer<TikTokDetectEvent> event) {
+            EventConsumer<TikTokDetectEvent> event) {
         tikTokEventHandler.subscribe(TikTokDetectEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkLayer(
-            TikTokEventConsumer<TikTokLinkLayerEvent> event) {
+            EventConsumer<TikTokLinkLayerEvent> event) {
         tikTokEventHandler.subscribe(TikTokLinkLayerEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onConnected(TikTokEventConsumer<TikTokConnectedEvent> event) {
+    public TikTokLiveClientBuilder onConnected(EventConsumer<TikTokConnectedEvent> event) {
         tikTokEventHandler.subscribe(TikTokConnectedEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onCaption(TikTokEventConsumer<TikTokCaptionEvent> event) {
+    public TikTokLiveClientBuilder onCaption(EventConsumer<TikTokCaptionEvent> event) {
         tikTokEventHandler.subscribe(TikTokCaptionEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onQuestion(TikTokEventConsumer<TikTokQuestionEvent> event) {
+    public TikTokLiveClientBuilder onQuestion(EventConsumer<TikTokQuestionEvent> event) {
         tikTokEventHandler.subscribe(TikTokQuestionEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onRoomPin(
-            TikTokEventConsumer<TikTokRoomPinEvent> event) {
+            EventConsumer<TikTokRoomPinEvent> event) {
         tikTokEventHandler.subscribe(TikTokRoomPinEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onRoom(TikTokEventConsumer<TikTokRoomEvent> event) {
+    public TikTokLiveClientBuilder onRoom(EventConsumer<TikTokRoomEvent> event) {
         tikTokEventHandler.subscribe(TikTokRoomEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLivePaused(TikTokEventConsumer<TikTokLivePausedEvent> event) {
+    public TikTokLiveClientBuilder onLivePaused(EventConsumer<TikTokLivePausedEvent> event) {
         tikTokEventHandler.subscribe(TikTokLivePausedEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLike(TikTokEventConsumer<TikTokLikeEvent> event) {
+    public TikTokLiveClientBuilder onLike(EventConsumer<TikTokLikeEvent> event) {
         tikTokEventHandler.subscribe(TikTokLikeEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLink(TikTokEventConsumer<TikTokLinkEvent> event) {
+    public TikTokLiveClientBuilder onLink(EventConsumer<TikTokLinkEvent> event) {
         tikTokEventHandler.subscribe(TikTokLinkEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onBarrage(
-            TikTokEventConsumer<TikTokBarrageEvent> event) {
+            EventConsumer<TikTokBarrageEvent> event) {
         tikTokEventHandler.subscribe(TikTokBarrageEvent.class, event);
         return this;
     }
 
 
-    public TikTokLiveClientBuilder onGift(TikTokEventConsumer<TikTokGiftEvent> event) {
+    public TikTokLiveClientBuilder onGift(EventConsumer<TikTokGiftEvent> event) {
         tikTokEventHandler.subscribe(TikTokGiftEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onGiftCombo(TikTokEventConsumer<TikTokGiftComboFinishedEvent> event) {
+    public TikTokLiveClientBuilder onGiftCombo(EventConsumer<TikTokGiftComboFinishedEvent> event) {
         tikTokEventHandler.subscribe(TikTokGiftComboFinishedEvent.class, event);
         return this;
     }
 
 
     public TikTokLiveClientBuilder onLinkMicArmies(
-            TikTokEventConsumer<TikTokLinkMicArmiesEvent> event) {
+            EventConsumer<TikTokLinkMicArmiesEvent> event) {
         tikTokEventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onEmote(TikTokEventConsumer<TikTokEmoteEvent> event) {
+    public TikTokLiveClientBuilder onEmote(EventConsumer<TikTokEmoteEvent> event) {
         tikTokEventHandler.subscribe(TikTokEmoteEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnauthorizedMember(
-            TikTokEventConsumer<TikTokUnauthorizedMemberEvent> event) {
+            EventConsumer<TikTokUnauthorizedMemberEvent> event) {
         tikTokEventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onInRoomBanner(
-            TikTokEventConsumer<TikTokInRoomBannerEvent> event) {
+            EventConsumer<TikTokInRoomBannerEvent> event) {
         tikTokEventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicMethod(
-            TikTokEventConsumer<TikTokLinkMicMethodEvent> event) {
+            EventConsumer<TikTokLinkMicMethodEvent> event) {
         tikTokEventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onSubscribe(TikTokEventConsumer<TikTokSubscribeEvent> event) {
+    public TikTokLiveClientBuilder onSubscribe(EventConsumer<TikTokSubscribeEvent> event) {
         tikTokEventHandler.subscribe(TikTokSubscribeEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onPoll(TikTokEventConsumer<TikTokPollEvent> event) {
+    public TikTokLiveClientBuilder onPoll(EventConsumer<TikTokPollEvent> event) {
         tikTokEventHandler.subscribe(TikTokPollEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onFollow(TikTokEventConsumer<TikTokFollowEvent> event) {
+    public TikTokLiveClientBuilder onFollow(EventConsumer<TikTokFollowEvent> event) {
         tikTokEventHandler.subscribe(TikTokFollowEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onRoomUserInfo(
-            TikTokEventConsumer<TikTokRoomUserInfoEvent> event) {
+            EventConsumer<TikTokRoomUserInfoEvent> event) {
         tikTokEventHandler.subscribe(TikTokRoomUserInfoEvent.class, event);
         return this;
     }
 
 
 
-    public TikTokLiveClientBuilder onComment(TikTokEventConsumer<TikTokCommentEvent> event) {
+    public TikTokLiveClientBuilder onComment(EventConsumer<TikTokCommentEvent> event) {
         tikTokEventHandler.subscribe(TikTokCommentEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onGoalUpdate(TikTokEventConsumer<TikTokGoalUpdateEvent> event) {
+    public TikTokLiveClientBuilder onGoalUpdate(EventConsumer<TikTokGoalUpdateEvent> event) {
         tikTokEventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
         return this;
     }
-    public TikTokLiveClientBuilder onRankUpdate(TikTokEventConsumer<TikTokRankUpdateEvent> event) {
+    public TikTokLiveClientBuilder onRankUpdate(EventConsumer<TikTokRankUpdateEvent> event) {
         tikTokEventHandler.subscribe(TikTokRankUpdateEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onIMDelete(TikTokEventConsumer<TikTokIMDeleteEvent> event) {
+    public TikTokLiveClientBuilder onIMDelete(EventConsumer<TikTokIMDeleteEvent> event) {
         tikTokEventHandler.subscribe(TikTokIMDeleteEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLiveEnded(TikTokEventConsumer<TikTokLiveEndedEvent> event) {
+    public TikTokLiveClientBuilder onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event) {
         tikTokEventHandler.subscribe(TikTokLiveEndedEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onError(TikTokEventConsumer<TikTokErrorEvent> event) {
+    public TikTokLiveClientBuilder onError(EventConsumer<TikTokErrorEvent> event) {
         tikTokEventHandler.subscribe(TikTokErrorEvent.class, event);
         return this;
     }
 
 
 
-    public TikTokLiveClientBuilder onJoin(TikTokEventConsumer<TikTokJoinEvent> event) {
+    public TikTokLiveClientBuilder onJoin(EventConsumer<TikTokJoinEvent> event) {
         tikTokEventHandler.subscribe(TikTokJoinEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onRankText(TikTokEventConsumer<TikTokRankTextEvent> event) {
+    public TikTokLiveClientBuilder onRankText(EventConsumer<TikTokRankTextEvent> event) {
         tikTokEventHandler.subscribe(TikTokRankTextEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onShare(TikTokEventConsumer<TikTokShareEvent> event) {
+    public TikTokLiveClientBuilder onShare(EventConsumer<TikTokShareEvent> event) {
         tikTokEventHandler.subscribe(TikTokShareEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnhandledMember(
-            TikTokEventConsumer<TikTokUnhandledMemberEvent> event) {
+            EventConsumer<TikTokUnhandledMemberEvent> event) {
         tikTokEventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onSubNotify(TikTokEventConsumer<TikTokSubNotifyEvent> event) {
+    public TikTokLiveClientBuilder onSubNotify(EventConsumer<TikTokSubNotifyEvent> event) {
         tikTokEventHandler.subscribe(TikTokSubNotifyEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicBattle(
-            TikTokEventConsumer<TikTokLinkMicBattleEvent> event) {
+            EventConsumer<TikTokLinkMicBattleEvent> event) {
         tikTokEventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onDisconnected(
-            TikTokEventConsumer<TikTokDisconnectedEvent> event) {
+            EventConsumer<TikTokDisconnectedEvent> event) {
         tikTokEventHandler.subscribe(TikTokDisconnectedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnhandledControl(
-            TikTokEventConsumer<TikTokUnhandledControlEvent> event) {
+            EventConsumer<TikTokUnhandledControlEvent> event) {
         tikTokEventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onEvent(TikTokEventConsumer<TikTokEvent> event) {
+    public TikTokLiveClientBuilder onEvent(EventConsumer<TikTokEvent> event) {
         tikTokEventHandler.subscribe(TikTokEvent.class, event);
         return this;
     }
 
     @Override
-    public TikTokLiveClientBuilder onWebsocketResponse(TikTokEventConsumer<TikTokWebsocketResponseEvent> event) {
+    public TikTokLiveClientBuilder onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event) {
         tikTokEventHandler.subscribe(TikTokWebsocketResponseEvent.class, event);
         return this;
     }
     @Override
-    public TikTokLiveClientBuilder onWebsocketMessage(TikTokEventConsumer<TikTokWebsocketMessageEvent> event) {
+    public TikTokLiveClientBuilder onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event) {
         tikTokEventHandler.subscribe(TikTokWebsocketMessageEvent.class, event);
         return this;
     }
 
     @Override
-    public TikTokLiveClientBuilder onWebsocketUnhandledMessage(TikTokEventConsumer<TikTokWebsocketUnhandledMessageEvent> event) {
+    public TikTokLiveClientBuilder onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event) {
         tikTokEventHandler.subscribe(TikTokWebsocketUnhandledMessageEvent.class, event);
         return this;
     }
 
     @Override
-    public TikTokLiveClientBuilder onReconnecting(TikTokEventConsumer<TikTokReconnectingEvent> event) {
+    public TikTokLiveClientBuilder onReconnecting(EventConsumer<TikTokReconnectingEvent> event) {
         tikTokEventHandler.subscribe(TikTokReconnectingEvent.class, event);
         return this;
     }

Client/src/main/java/io/github/jwdeveloper/tiktok/handlers/TikTokEventObserver.java

@@ -23,7 +23,7 @@
 package io.github.jwdeveloper.tiktok.handlers;
 
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventConsumer;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 
 import java.util.HashMap;
@@ -32,7 +32,7 @@ import java.util.Map;
 import java.util.Set;
 
 public class TikTokEventObserver {
-    private final Map<Class<?>, Set<TikTokEventConsumer>> events;
+    private final Map<Class<?>, Set<EventConsumer>> events;
 
     public TikTokEventObserver() {
         events = new HashMap<>();
@@ -56,7 +56,7 @@ public class TikTokEventObserver {
         }
     }
 
-    public <T extends TikTokEvent> void subscribe(Class<?> clazz, TikTokEventConsumer<T> event) {
+    public <T extends TikTokEvent> void subscribe(Class<?> clazz, EventConsumer<T> event) {
         events.computeIfAbsent(clazz, e -> new HashSet<>()).add(event);
     }
 
@@ -64,13 +64,13 @@ public class TikTokEventObserver {
         events.remove(clazz);
     }
 
-    public <T extends TikTokEvent> void unsubscribe(TikTokEventConsumer<T> consumer) {
+    public <T extends TikTokEvent> void unsubscribe(EventConsumer<T> consumer) {
         for (var entry : events.entrySet()) {
             entry.getValue().remove(consumer);
         }
     }
 
-    public <T extends TikTokEvent> void unsubscribe(Class<?> clazz, TikTokEventConsumer<T> consumer) {
+    public <T extends TikTokEvent> void unsubscribe(Class<?> clazz, EventConsumer<T> consumer) {
         if (clazz == null) {
             return;
         }

Client/src/main/java/io/github/jwdeveloper/tiktok/listener/ListenerBindingModel.java

@@ -22,7 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok.listener;
 
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventConsumer;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 
 import lombok.Value;
 
@@ -36,5 +36,5 @@ public class ListenerBindingModel
 
     TikTokEventListener listener;
 
-    Map<Class<?>, List<TikTokEventConsumer<?>>> events;
+    Map<Class<?>, List<EventConsumer<?>>> events;
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/listener/TikTokListenersManager.java

@@ -25,7 +25,7 @@ package io.github.jwdeveloper.tiktok.listener;
 
 import io.github.jwdeveloper.tiktok.annotations.TikTokEventHandler;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventConsumer;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokEventListenerMethodException;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
@@ -91,7 +91,7 @@ public class TikTokListenersManager implements ListenersManager {
         var methods = Arrays.stream(clazz.getDeclaredMethods()).filter(m ->
                 m.getParameterCount() == 2 &&
                         m.isAnnotationPresent(TikTokEventHandler.class)).toList();
-        var eventsMap = new HashMap<Class<?>, List<TikTokEventConsumer<?>>>();
+        var eventsMap = new HashMap<Class<?>, List<EventConsumer<?>>>();
         for (var method : methods) {
             var eventClazz = method.getParameterTypes()[1];
 
@@ -105,7 +105,7 @@ public class TikTokListenersManager implements ListenersManager {
                 throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 2nd parameter must instance of " + TikTokEvent.class.getName());
             }
 
-            TikTokEventConsumer eventMethodRef = (liveClient, event) ->
+            EventConsumer eventMethodRef = (liveClient, event) ->
             {
                 try {
                     method.invoke(listener, liveClient, event);
@@ -113,7 +113,7 @@ public class TikTokListenersManager implements ListenersManager {
                     throw new TikTokEventListenerMethodException(e);
                 }
             };
-            eventsMap.computeIfAbsent(eventClazz, (a) -> new ArrayList<TikTokEventConsumer<?>>()).add(eventMethodRef);
+            eventsMap.computeIfAbsent(eventClazz, (a) -> new ArrayList<EventConsumer<?>>()).add(eventMethodRef);
         }
         return new ListenerBindingModel(listener, eventsMap);
     }

Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/LiveRoomMetaMapper.java

@@ -25,9 +25,9 @@ package io.github.jwdeveloper.tiktok.mappers;
 import com.google.gson.JsonObject;
 import io.github.jwdeveloper.tiktok.live.LiveRoomMeta;
 
-public class LiveRoomMetaMapper implements Mapper<JsonObject, LiveRoomMeta> 
+public class LiveRoomMetaMapper
 {
-    @Override
+
     public LiveRoomMeta map(JsonObject input) {
         var liveRoomMeta = new LiveRoomMeta();
 

Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/messages/TikTokLikeEventMapper.java

@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-package io.github.jwdeveloper.tiktok.mappers.messages;
-
-import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
-import io.github.jwdeveloper.tiktok.mappers.Mapper;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLikeMessage;
-
-public class TikTokLikeEventMapper implements Mapper<WebcastLikeMessage, TikTokLikeEvent>
-{
-
-
-    @Override
-    public TikTokLikeEvent map(WebcastLikeMessage webcastLikeMessage) {
-        return null;
-    }
-}

TestApplication/src/main/java/io/github/jwdeveloper/tiktok/ConfigurationExample.java

@@ -32,7 +32,7 @@ public class ConfigurationExample {
         TikTokLive.newClient(Main.TEST_TIKTOK_USER)
                 .configure(clientSettings ->
                 {
-                    clientSettings.setHostName(Main.TEST_TIKTOK_USER); // TikTok user name
+                    clientSettings.setHostName(Main.TEST_TIKTOK_USER); // TikTok hostname
                     clientSettings.setClientLanguage("en"); // Language
                     clientSettings.setTimeout(Duration.ofSeconds(2)); // Connection timeout
                     clientSettings.setLogLevel(Level.ALL); // Log level
@@ -49,6 +49,7 @@ public class ConfigurationExample {
                     clientSettings.setRoomId("XXXXXXXXXXXXXXXXX");
                 })
                 .buildAndConnect();
+
         System.in.read();
     }
 }

TestApplication/src/main/java/io/github/jwdeveloper/tiktok/Main.java

@@ -51,9 +51,9 @@ public class Main {
                     clientSettings.setRetryOnConnectionFailure(true);
                     clientSettings.setHandleExistingEvents(true);
                 })
-                .onGift((liveClient, event) ->
+                .onError((liveClient, event) ->
                 {
-                    var  i=0;
+
                 })
                 .onConnected(Main::onConnected)
                 .onDisconnected(Main::onDisconnected)

Tools-ReadmeGenerator/src/main/java/io/github/jwdeveloper/tiktok/FullEventsExampleClass.java

@@ -66,10 +66,6 @@ public class FullEventsExampleClass
                 .onComment((liveClient, event) ->
                 {
 
-                })
-                .onEnvelope((liveClient, event) ->
-                {
-
                 })
                 .onLiveEnded((liveClient, event) ->
                 {