Make Event Engine code internal.

pubnub · Oct 25, 2023 · 0cc0511 · 0cc0511
1 parent 2c461d0
commit 0cc0511
Show file tree

Hide file tree

Showing 54 changed files with 75 additions and 75 deletions.
diff --git a/src/main/kotlin/com/pubnub/api/eventengine/Effect.kt b/src/main/kotlin/com/pubnub/api/eventengine/Effect.kt
@@ -1,5 +1,5 @@
 package com.pubnub.api.eventengine
 
-interface Effect {
+internal interface Effect {
     fun runEffect()
 }
diff --git a/src/main/kotlin/com/pubnub/api/eventengine/EffectDispatcher.kt b/src/main/kotlin/com/pubnub/api/eventengine/EffectDispatcher.kt
@@ -5,7 +5,7 @@ import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 
-class EffectDispatcher<T : EffectInvocation>(
+internal class EffectDispatcher<T : EffectInvocation>(
     private val effectFactory: EffectFactory<T>,
     private val effectSource: Source<T>,
     private val managedEffects: ConcurrentHashMap<String, ManagedEffect> = ConcurrentHashMap(),

diff --git a/src/main/kotlin/com/pubnub/api/eventengine/EffectFactory.kt b/src/main/kotlin/com/pubnub/api/eventengine/EffectFactory.kt
@@ -1,5 +1,5 @@
 package com.pubnub.api.eventengine
 
-interface EffectFactory<T : EffectInvocation> {
+internal interface EffectFactory<T : EffectInvocation> {
     fun create(effectInvocation: T): Effect?
 }
diff --git a/src/main/kotlin/com/pubnub/api/eventengine/EffectInvocation.kt b/src/main/kotlin/com/pubnub/api/eventengine/EffectInvocation.kt
@@ -1,14 +1,14 @@
 package com.pubnub.api.eventengine
 
-interface EffectInvocation {
+internal interface EffectInvocation {
     val id: String
     val type: EffectInvocationType
 }
 
-sealed interface EffectInvocationType
+internal sealed interface EffectInvocationType
 
-data class Cancel(val idToCancel: String) : EffectInvocationType
+internal data class Cancel(val idToCancel: String) : EffectInvocationType
 
-object Managed : EffectInvocationType
+internal object Managed : EffectInvocationType
 
-object NonManaged : EffectInvocationType
+internal object NonManaged : EffectInvocationType
diff --git a/src/main/kotlin/com/pubnub/api/eventengine/Event.kt b/src/main/kotlin/com/pubnub/api/eventengine/Event.kt
@@ -1,3 +1,3 @@
 package com.pubnub.api.eventengine
 
-interface Event
+internal interface Event
diff --git a/src/main/kotlin/com/pubnub/api/eventengine/EventEngine.kt b/src/main/kotlin/com/pubnub/api/eventengine/EventEngine.kt
@@ -3,7 +3,7 @@ package com.pubnub.api.eventengine
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
 
-class EventEngine<Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>>(
+internal class EventEngine<Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>>(
     private val effectSink: Sink<Ei>,
     private val eventSource: Source<Ev>,
     private var currentState: S,

diff --git a/src/main/kotlin/com/pubnub/api/eventengine/EventEngineConf.kt b/src/main/kotlin/com/pubnub/api/eventengine/EventEngineConf.kt
@@ -1,13 +1,13 @@
 package com.pubnub.api.eventengine
 
-interface EventEngineConf<Ei : EffectInvocation, Ev : Event> {
+internal interface EventEngineConf<Ei : EffectInvocation, Ev : Event> {
     val eventSink: Sink<Ev>
     val eventSource: Source<Ev>
     val effectSink: Sink<Ei>
     val effectSource: Source<Ei>
 }
 
-class QueueEventEngineConf<Ei : EffectInvocation, Ev : Event>(
+internal class QueueEventEngineConf<Ei : EffectInvocation, Ev : Event>(
     effectSinkSource: SinkSource<Ei> = QueueSinkSource(),
     eventSinkSource: SinkSource<Ev> = QueueSinkSource()
 ) : EventEngineConf<Ei, Ev> {

diff --git a/src/main/kotlin/com/pubnub/api/eventengine/EventEngineManager.kt b/src/main/kotlin/com/pubnub/api/eventengine/EventEngineManager.kt
@@ -1,6 +1,6 @@
 package com.pubnub.api.eventengine
 
-class EventEngineManager<Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>, Ee : EventEngine<Ei, Ev, S>>(
+internal class EventEngineManager<Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>, Ee : EventEngine<Ei, Ev, S>>(
     private val eventEngine: Ee,
     private val effectDispatcher: EffectDispatcher<Ei>,
     private val eventSink: Sink<Ev>

diff --git a/src/main/kotlin/com/pubnub/api/eventengine/ManagedEffect.kt b/src/main/kotlin/com/pubnub/api/eventengine/ManagedEffect.kt
@@ -1,5 +1,5 @@
 package com.pubnub.api.eventengine
 
-interface ManagedEffect : Effect {
+internal interface ManagedEffect : Effect {
     fun cancel()
 }
diff --git a/src/main/kotlin/com/pubnub/api/eventengine/QueueSinkSource.kt b/src/main/kotlin/com/pubnub/api/eventengine/QueueSinkSource.kt
@@ -3,9 +3,9 @@ package com.pubnub.api.eventengine
 import java.util.concurrent.BlockingQueue
 import java.util.concurrent.LinkedBlockingQueue
 
-interface SinkSource<T> : Sink<T>, Source<T>
+internal interface SinkSource<T> : Sink<T>, Source<T>
 
-class QueueSinkSource<T>(private val queue: BlockingQueue<T> = LinkedBlockingQueue()) : SinkSource<T> {
+internal class QueueSinkSource<T>(private val queue: BlockingQueue<T> = LinkedBlockingQueue()) : SinkSource<T> {
     override fun take(): T {
         return queue.take()
     }

diff --git a/src/main/kotlin/com/pubnub/api/eventengine/Sink.kt b/src/main/kotlin/com/pubnub/api/eventengine/Sink.kt
@@ -1,5 +1,5 @@
 package com.pubnub.api.eventengine
 
-interface Sink<T> {
+internal interface Sink<T> {
     fun add(item: T)
 }
diff --git a/src/main/kotlin/com/pubnub/api/eventengine/Source.kt b/src/main/kotlin/com/pubnub/api/eventengine/Source.kt
@@ -1,5 +1,5 @@
 package com.pubnub.api.eventengine
 
-interface Source<T> {
+internal interface Source<T> {
     fun take(): T
 }
diff --git a/src/main/kotlin/com/pubnub/api/eventengine/State.kt b/src/main/kotlin/com/pubnub/api/eventengine/State.kt
@@ -1,13 +1,13 @@
 package com.pubnub.api.eventengine
 
-interface State<Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>> {
+internal interface State<Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>> {
     open fun onEntry(): Set<Ei> = setOf()
     open fun onExit(): Set<Ei> = setOf()
     abstract fun transition(event: Ev): Pair<S, Set<Ei>>
 }
 
-fun <Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>> S.noTransition(): Pair<S, Set<Ei>> = Pair(this, emptySet())
-fun <Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>> S.transitionTo(
+internal fun <Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>> S.noTransition(): Pair<S, Set<Ei>> = Pair(this, emptySet())
+internal fun <Ei : EffectInvocation, Ev : Event, S : State<Ei, Ev, S>> S.transitionTo(
     state: S,
     vararg invocations: Ei
 ): Pair<S, Set<Ei>> {

diff --git a/src/main/kotlin/com/pubnub/api/managers/PresenceEventEngineManager.kt b/src/main/kotlin/com/pubnub/api/managers/PresenceEventEngineManager.kt
@@ -6,4 +6,4 @@ import com.pubnub.api.presence.eventengine.effect.PresenceEffectInvocation
 import com.pubnub.api.presence.eventengine.event.PresenceEvent
 import com.pubnub.api.presence.eventengine.state.PresenceState
 
-typealias PresenceEventEngineManager = EventEngineManager<PresenceEffectInvocation, PresenceEvent, PresenceState, PresenceEventEngine>
+internal typealias PresenceEventEngineManager = EventEngineManager<PresenceEffectInvocation, PresenceEvent, PresenceState, PresenceEventEngine>
diff --git a/src/main/kotlin/com/pubnub/api/managers/SubscribeEventEngineManager.kt b/src/main/kotlin/com/pubnub/api/managers/SubscribeEventEngineManager.kt
@@ -6,4 +6,4 @@ import com.pubnub.api.subscribe.eventengine.effect.SubscribeEffectInvocation
 import com.pubnub.api.subscribe.eventengine.event.SubscribeEvent
 import com.pubnub.api.subscribe.eventengine.state.SubscribeState
 
-typealias SubscribeEventEngineManager = EventEngineManager<SubscribeEffectInvocation, SubscribeEvent, SubscribeState, SubscribeEventEngine>
+internal typealias SubscribeEventEngineManager = EventEngineManager<SubscribeEffectInvocation, SubscribeEvent, SubscribeState, SubscribeEventEngine>
diff --git a/src/main/kotlin/com/pubnub/api/presence/Presence.kt b/src/main/kotlin/com/pubnub/api/presence/Presence.kt
@@ -13,7 +13,7 @@ import com.pubnub.api.subscribe.eventengine.effect.RetryPolicy
 import java.time.Duration
 import java.util.concurrent.Executors
 
-interface Presence {
+internal interface Presence {
     companion object {
         internal fun create(
             heartbeatProvider: HeartbeatProvider,

diff --git a/src/main/kotlin/com/pubnub/api/presence/eventengine/PresenceEventEngine.kt b/src/main/kotlin/com/pubnub/api/presence/eventengine/PresenceEventEngine.kt
@@ -7,9 +7,9 @@ import com.pubnub.api.presence.eventengine.effect.PresenceEffectInvocation
 import com.pubnub.api.presence.eventengine.event.PresenceEvent
 import com.pubnub.api.presence.eventengine.state.PresenceState
 
-typealias PresenceEventEngine = EventEngine<PresenceEffectInvocation, PresenceEvent, PresenceState>
+internal typealias PresenceEventEngine = EventEngine<PresenceEffectInvocation, PresenceEvent, PresenceState>
 
-fun PresenceEventEngine(
+internal fun PresenceEventEngine(
     effectSink: Sink<PresenceEffectInvocation>,
     eventSource: Source<PresenceEvent>,
     currentState: PresenceState = PresenceState.HeartbeatInactive,

diff --git a/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/HeartbeatEffect.kt b/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/HeartbeatEffect.kt
@@ -7,7 +7,7 @@ import com.pubnub.api.eventengine.Sink
 import com.pubnub.api.presence.eventengine.event.PresenceEvent
 import org.slf4j.LoggerFactory
 
-class HeartbeatEffect(
+internal class HeartbeatEffect(
     private val heartbeatRemoteAction: RemoteAction<Boolean>,
     private val presenceEventSink: Sink<PresenceEvent>
 ) : Effect {

diff --git a/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/LeaveEffect.kt b/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/LeaveEffect.kt
@@ -4,7 +4,7 @@ import com.pubnub.api.endpoints.remoteaction.RemoteAction
 import com.pubnub.api.eventengine.Effect
 import org.slf4j.LoggerFactory
 
-class LeaveEffect(
+internal class LeaveEffect(
     private val leaveRemoteAction: RemoteAction<Boolean>
 ) : Effect {
     private val log = LoggerFactory.getLogger(LeaveEffect::class.java)

diff --git a/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/PresenceEffectInvocation.kt b/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/PresenceEffectInvocation.kt
@@ -7,7 +7,7 @@ import com.pubnub.api.eventengine.EffectInvocationType
 import com.pubnub.api.eventengine.Managed
 import com.pubnub.api.eventengine.NonManaged
 
-sealed class PresenceEffectInvocation(override val type: EffectInvocationType) : EffectInvocation {
+internal sealed class PresenceEffectInvocation(override val type: EffectInvocationType) : EffectInvocation {
     override val id: String = "any value for NonManged and Cancel effect"
 
     data class Heartbeat(

diff --git a/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/WaitEffect.kt b/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/WaitEffect.kt
@@ -9,9 +9,9 @@ import java.util.concurrent.Executors
 import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.ScheduledFuture
 
-class WaitEffect( // todo handle pubnub.configuration.heartbeatInterval <= 0
-    private val heartbeatInterval: Duration, // todo if the interval is 0 or less, do not start the timer
-    private val presenceEventSink: Sink<PresenceEvent>, // todo this should  be check at PresenceEventEngineCreation
+internal class WaitEffect(
+    private val heartbeatInterval: Duration,
+    private val presenceEventSink: Sink<PresenceEvent>,
     private val executorService: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor()
 ) : ManagedEffect {
 

diff --git a/...ain/kotlin/com/pubnub/api/presence/eventengine/effect/effectprovider/HeartbeatProvider.kt b/...ain/kotlin/com/pubnub/api/presence/eventengine/effect/effectprovider/HeartbeatProvider.kt
@@ -2,6 +2,6 @@ package com.pubnub.api.presence.eventengine.effect.effectprovider
 
 import com.pubnub.api.endpoints.remoteaction.RemoteAction
 
-fun interface HeartbeatProvider {
+internal fun interface HeartbeatProvider {
     fun getHeartbeatRemoteAction(channels: Set<String>, channelGroups: Set<String>): RemoteAction<Boolean>
 }
diff --git a/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/effectprovider/LeaveProvider.kt b/src/main/kotlin/com/pubnub/api/presence/eventengine/effect/effectprovider/LeaveProvider.kt
@@ -2,6 +2,6 @@ package com.pubnub.api.presence.eventengine.effect.effectprovider
 
 import com.pubnub.api.endpoints.remoteaction.RemoteAction
 
-fun interface LeaveProvider {
+internal fun interface LeaveProvider {
     fun getLeaveRemoteAction(channels: Set<String>, channelGroups: Set<String>): RemoteAction<Boolean>
 }
diff --git a/src/main/kotlin/com/pubnub/api/presence/eventengine/event/PresenceEvent.kt b/src/main/kotlin/com/pubnub/api/presence/eventengine/event/PresenceEvent.kt
@@ -3,7 +3,7 @@ package com.pubnub.api.presence.eventengine.event
 import com.pubnub.api.PubNubException
 import com.pubnub.api.eventengine.Event
 
-sealed class PresenceEvent : Event {
+internal sealed class PresenceEvent : Event {
     data class Joined(val channels: Set<String>, val channelGroups: Set<String>) : PresenceEvent()
     data class Left(val channels: Set<String>, val channelGroups: Set<String>) : PresenceEvent()
 

diff --git a/src/main/kotlin/com/pubnub/api/presence/eventengine/state/PresenceState.kt b/src/main/kotlin/com/pubnub/api/presence/eventengine/state/PresenceState.kt
@@ -7,7 +7,7 @@ import com.pubnub.api.eventengine.transitionTo
 import com.pubnub.api.presence.eventengine.effect.PresenceEffectInvocation
 import com.pubnub.api.presence.eventengine.event.PresenceEvent
 
-sealed class PresenceState : State<PresenceEffectInvocation, PresenceEvent, PresenceState> {
+internal sealed class PresenceState : State<PresenceEffectInvocation, PresenceEvent, PresenceState> {
     object HeartbeatInactive : PresenceState() {
         override fun transition(event: PresenceEvent): Pair<PresenceState, Set<PresenceEffectInvocation>> {
             return when (event) {

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/Subscribe.kt b/src/main/kotlin/com/pubnub/api/subscribe/Subscribe.kt
@@ -22,7 +22,7 @@ import java.util.concurrent.Executors
 
 private const val PRESENCE_CHANNEL_SUFFIX = "-pnpres"
 
-class Subscribe(
+internal class Subscribe(
     private val subscribeEventEngineManager: SubscribeEventEngineManager,
     private val subscriptionData: SubscriptionData = SubscriptionData()
 ) {

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/SubscribeEventEngine.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/SubscribeEventEngine.kt
@@ -7,9 +7,9 @@ import com.pubnub.api.subscribe.eventengine.effect.SubscribeEffectInvocation
 import com.pubnub.api.subscribe.eventengine.event.SubscribeEvent
 import com.pubnub.api.subscribe.eventengine.state.SubscribeState
 
-typealias SubscribeEventEngine = EventEngine<SubscribeEffectInvocation, SubscribeEvent, SubscribeState>
+internal typealias SubscribeEventEngine = EventEngine<SubscribeEffectInvocation, SubscribeEvent, SubscribeState>
 
-fun SubscribeEventEngine(
+internal fun SubscribeEventEngine(
     effectSink: Sink<SubscribeEffectInvocation>,
     eventSource: Source<SubscribeEvent>,
     currentState: SubscribeState = SubscribeState.Unsubscribed

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/configuration/EventEnginesConf.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/configuration/EventEnginesConf.kt
@@ -7,7 +7,7 @@ import com.pubnub.api.presence.eventengine.event.PresenceEvent
 import com.pubnub.api.subscribe.eventengine.effect.SubscribeEffectInvocation
 import com.pubnub.api.subscribe.eventengine.event.SubscribeEvent
 
-class EventEnginesConf(
+internal class EventEnginesConf(
     val subscribe: EventEngineConf<SubscribeEffectInvocation, SubscribeEvent> = QueueEventEngineConf(),
     val presence: EventEngineConf<PresenceEffectInvocation, PresenceEvent> = QueueEventEngineConf()
 )
diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/data/SubscriptionData.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/data/SubscriptionData.kt
@@ -1,6 +1,6 @@
 package com.pubnub.api.subscribe.eventengine.data
 
-class SubscriptionData {
+internal class SubscriptionData {
     internal val channels: MutableSet<String> = mutableSetOf()
     internal val channelGroups: MutableSet<String> = mutableSetOf()
 }
diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/EmitMessagesEffect.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/EmitMessagesEffect.kt
@@ -10,7 +10,7 @@ import com.pubnub.api.models.consumer.pubsub.message_actions.PNMessageActionResu
 import com.pubnub.api.models.consumer.pubsub.objects.PNObjectEventResult
 import org.slf4j.LoggerFactory
 
-class EmitMessagesEffect(
+internal class EmitMessagesEffect(
     private val messagesConsumer: MessagesConsumer,
     private val messages: List<PNEvent>
 ) : Effect {

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/EmitStatusEffect.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/EmitStatusEffect.kt
@@ -4,7 +4,7 @@ import com.pubnub.api.eventengine.Effect
 import com.pubnub.api.models.consumer.PNStatus
 import org.slf4j.LoggerFactory
 
-class EmitStatusEffect(
+internal class EmitStatusEffect(
     private val statusConsumer: StatusConsumer,
     private val status: PNStatus
 ) : Effect {

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/HandshakeEffect.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/HandshakeEffect.kt
@@ -8,7 +8,7 @@ import com.pubnub.api.subscribe.eventengine.event.SubscribeEvent
 import com.pubnub.api.subscribe.eventengine.event.SubscriptionCursor
 import org.slf4j.LoggerFactory
 
-class HandshakeEffect(
+internal class HandshakeEffect(
     private val handshakeRemoteAction: RemoteAction<SubscriptionCursor>,
     private val subscribeEventSink: Sink<SubscribeEvent>,
 ) : ManagedEffect {

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/HandshakeReconnectEffect.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/HandshakeReconnectEffect.kt
@@ -11,7 +11,7 @@ import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.ScheduledFuture
 import java.util.concurrent.TimeUnit
 
-class HandshakeReconnectEffect(
+internal class HandshakeReconnectEffect(
     private val handshakeRemoteAction: RemoteAction<SubscriptionCursor>,
     private val subscribeEventSink: Sink<SubscribeEvent>,
     private val policy: RetryPolicy,

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/MessagesConsumer.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/MessagesConsumer.kt
@@ -7,7 +7,7 @@ import com.pubnub.api.models.consumer.pubsub.files.PNFileEventResult
 import com.pubnub.api.models.consumer.pubsub.message_actions.PNMessageActionResult
 import com.pubnub.api.models.consumer.pubsub.objects.PNObjectEventResult
 
-interface MessagesConsumer {
+internal interface MessagesConsumer {
     fun announce(message: PNMessageResult)
 
     fun announce(presence: PNPresenceEventResult)

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/ReceiveMessagesEffect.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/ReceiveMessagesEffect.kt
@@ -7,7 +7,7 @@ import com.pubnub.api.eventengine.Sink
 import com.pubnub.api.subscribe.eventengine.event.SubscribeEvent
 import org.slf4j.LoggerFactory
 
-class ReceiveMessagesEffect(
+internal class ReceiveMessagesEffect(
     private val receiveMessagesRemoteAction: RemoteAction<ReceiveMessagesResult>,
     private val subscribeEventSink: Sink<SubscribeEvent>,
 ) : ManagedEffect {
@@ -21,7 +21,7 @@ class ReceiveMessagesEffect(
                 subscribeEventSink.add(
                     SubscribeEvent.ReceiveFailure(
                         status.exception
-                            ?: PubNubException("Unknown error") // todo check it that can happen
+                            ?: PubNubException("Unknown error")
                     )
                 )
             } else {

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/ReceiveReconnectEffect.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/ReceiveReconnectEffect.kt
@@ -10,7 +10,7 @@ import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.ScheduledFuture
 import java.util.concurrent.TimeUnit
 
-class ReceiveReconnectEffect(
+internal class ReceiveReconnectEffect(
     private val receiveMessagesRemoteAction: RemoteAction<ReceiveMessagesResult>,
     private val subscribeEventSink: Sink<SubscribeEvent>,
     private val policy: RetryPolicy,

diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/ReconnectionPolicy.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/ReconnectionPolicy.kt
@@ -3,7 +3,7 @@ package com.pubnub.api.subscribe.eventengine.effect
 import java.time.Duration
 import kotlin.math.pow
 
-abstract class RetryPolicy {
+internal abstract class RetryPolicy {
     protected abstract val maxRetries: Int
     protected abstract fun computeDelay(count: Int): Duration
     fun nextDelay(attempt: Int): Duration? {
@@ -14,18 +14,18 @@ abstract class RetryPolicy {
     }
 }
 
-object NoRetriesPolicy : RetryPolicy() {
+internal object NoRetriesPolicy : RetryPolicy() {
     override val maxRetries: Int = 0
     override fun computeDelay(count: Int): Duration = Duration.ZERO
 }
 
-class LinearPolicy(
+internal class LinearPolicy(
     override val maxRetries: Int = 5, // LinearPolicy is created in PNConfiguration default maxRetries is -1 which is unlimited
     private val fixedDelay: Duration = Duration.ofSeconds(3)
 ) : RetryPolicy() {
     override fun computeDelay(count: Int): Duration = fixedDelay
 }
 
-class ExponentialPolicy(override val maxRetries: Int = 5) : RetryPolicy() { // LinearPolicy is created in PNConfiguration default maxRetries is -1 which is unlimited
+internal class ExponentialPolicy(override val maxRetries: Int = 5) : RetryPolicy() { // LinearPolicy is created in PNConfiguration default maxRetries is -1 which is unlimited
     override fun computeDelay(count: Int): Duration = Duration.ofSeconds((2.0.pow(count - 1)).toLong())
 }
diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/StatusConsumer.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/StatusConsumer.kt
@@ -2,6 +2,6 @@ package com.pubnub.api.subscribe.eventengine.effect
 
 import com.pubnub.api.models.consumer.PNStatus
 
-interface StatusConsumer {
+internal interface StatusConsumer {
     fun announce(status: PNStatus)
 }
diff --git a/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/SubscribeEffectFactory.kt b/src/main/kotlin/com/pubnub/api/subscribe/eventengine/effect/SubscribeEffectFactory.kt
@@ -12,7 +12,7 @@ import com.pubnub.api.subscribe.eventengine.event.SubscriptionCursor
 import java.util.concurrent.Executors
 import java.util.concurrent.ScheduledExecutorService
 
-data class ReceiveMessagesResult(
+internal data class ReceiveMessagesResult(
     val messages: List<PNEvent>,
     val subscriptionCursor: SubscriptionCursor
 )