pg_eventstore 1.13.4 → 3.0.0

data/sig/pg_eventstore/subscriptions/events_processor_consumer/multiple.rbs

@@ -0,0 +1,17 @@
+module PgEventstore
+  module EventsProcessorConsumer
+    class Multiple
+      EVENTS_WAIT_TIMEOUT: Integer | Float
+
+      include EventsProcessorConsumer
+      extend ClassMethods
+
+      @handler: _RawEventsHandler
+
+      @last_unprocessed_events: Array[Hash[String, untyped]]?
+
+      def initialize: (_RawEventsHandler handler) -> void
+    end
+  end
+end
+

data/sig/pg_eventstore/subscriptions/events_processor_consumer/replica.rbs

@@ -0,0 +1,17 @@
+module PgEventstore
+  module EventsProcessorConsumer
+    class Replica
+      include EventsProcessorConsumer
+
+      EVENTS_WAIT_TIMEOUT: Float | Integer
+
+      @handler: Proc
+
+      @last_unprocessed_events: Array[EventGlobalIndex::SubscriptionRepr]?
+
+      def self.create_consumer: (Symbol config_name, Symbol replica_config_name) -> Replica
+
+      def initialize: (Proc handler) -> void
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/events_processor_consumer/single.rbs

@@ -0,0 +1,17 @@
+module PgEventstore
+  module EventsProcessorConsumer
+    class Single
+      EVENT_WAIT_TIMEOUT: Float | Integer
+
+      include EventsProcessorConsumer
+      extend ClassMethods
+
+      @handler: _RawEventHandler
+
+      @last_unprocessed_event: Hash[String, untyped]?
+
+      def initialize: (_RawEventHandler handler) -> void
+    end
+  end
+end
+

data/sig/pg_eventstore/subscriptions/events_processor_consumer.rbs

@@ -0,0 +1,14 @@
+module PgEventstore
+  module EventsProcessorConsumer
+    module ClassMethods
+      def create_consumer: (_SubscriptionHandler handler, EventDeserializer deserializer) -> EventsProcessorConsumer
+    end
+
+    def self.consumer_class: (bool in_batches) -> Class
+
+    def call: (Callbacks callbacks, Chunks::Repository repository,
+        MonitorMixin::ConditionVariable repository_cond) -> void
+
+    def clear_unprocessed_events: -> void
+  end
+end

data/sig/pg_eventstore/subscriptions/events_subscription_position_worker.rbs

@@ -0,0 +1,28 @@
+module PgEventstore
+  class EventsSubscriptionPositionWorker
+    class ReindexTime
+      include Extensions::OptionsExtension
+      include Extensions::OptionsDefaults
+
+      attr_accessor time: Time?
+    end
+
+    @basic_runner: BasicRunner
+
+    @next_reindex_at: ReindexTime
+
+    attr_reader config_name: Symbol
+
+    def initialize: (Symbol config_name) -> void
+
+    private
+
+    def attach_runner_callbacks: -> void
+
+    def config: -> Config
+
+    def connection: -> Connection
+
+    def event_subscription_position_queries: -> EventSubscriptionPositionQueries
+  end
+end

data/sig/pg_eventstore/subscriptions/queries/subscription_queries.rbs

@@ -1,73 +1,41 @@
 module PgEventstore
   class SubscriptionQueries
-    # _@param_ `connection`
-    def initialize: (PgEventstore::Connection connection) -> void
+    @query_strategy: QueryStrategy
 
-    # _@param_ `attrs`
-    def find_or_create_by: (::Hash[untyped, untyped] attrs) -> ::Hash[untyped, untyped]
+    attr_accessor connection: Connection
 
-    # _@param_ `attrs`
-    def find_by: (::Hash[untyped, untyped] attrs) -> ::Hash[untyped, untyped]?
+    def initialize: (Connection connection, QueryStrategy query_strategy) -> void
 
-    # _@param_ `attrs`
-    def find_all: (::Hash[untyped, untyped] attrs) -> ::Array[::Hash[untyped, untyped]]
+    def create_or_replace_table_function: (Integer id, Hash[untyped, untyped] options, Integer locked_by) -> void
+
+    def find_or_create_by: (::Hash[untyped, untyped] attrs) -> ::Hash[Symbol, untyped]
+
+    def find_by: (::Hash[untyped, untyped] attrs) -> ::Hash[Symbol, untyped]?
+
+    def find_all: (::Hash[untyped, untyped] attrs) -> ::Array[::Hash[Symbol, untyped]]
 
     def set_collection: (?String? state) -> ::Array[String]
 
-    # _@param_ `id`
-    def find!: (Integer id) -> ::Hash[untyped, untyped]
+    def find!: (Integer id) -> ::Hash[Symbol, untyped]
 
-    # _@param_ `attrs`
-    def create: (::Hash[untyped, untyped] attrs) -> ::Hash[untyped, untyped]
+    def create: (::Hash[untyped, untyped] attrs) -> ::Hash[Symbol, untyped]
 
-    # _@param_ `id`
-    #
-    # _@param_ `attrs`
-    #
-    # _@param_ `locked_by`
-    def update: (Integer id, attrs: ::Hash[untyped, untyped], locked_by: Integer?) -> ::Hash[untyped, untyped]
+    def update: (Integer id, attrs: ::Hash[Symbol, untyped], locked_by: Integer?) -> ::Hash[Symbol, untyped]
 
-    # _@param_ `subscriptions_set_id` — SubscriptionsSet#id
-    #
-    # _@param_ `subscriptions_ids` — Array of Subscription#id
     def ping_all: (Integer subscriptions_set_id, ::Array[Integer] subscriptions_ids) -> ::Hash[Integer, Time]
 
-    # _@param_ `query_options` — runner_id/query options association
-    #
-    # _@return_ — runner_id/events association
-    def subscriptions_events: (::Hash[Integer, ::Hash[untyped, untyped]] query_options) -> ::Hash[Integer, Array[::Hash[untyped, untyped]]]
-
-    # _@param_ `id` — subscription's id
-    #
-    # _@param_ `lock_id` — id of the subscriptions set which reserves the subscription
-    #
-    # _@param_ `force` — whether to lock the subscription despite on #locked_by value
-    #
-    # _@return_ — lock id
     def lock!: (Integer id, Integer lock_id, ?force: bool) -> Integer
 
-    # _@param_ `id`
     def delete: (Integer id) -> void
 
-    # _@param_ `id` — runner id
-    #
-    # _@param_ `options` — query options
-    def query_builder: (Integer id, ::Hash[untyped, untyped] options) -> PgEventstore::SQLBuilder
-
-    # _@param_ `builders`
-    def union_builders: (::Array[PgEventstore::SQLBuilder] builders) -> PgEventstore::SQLBuilder
-
-    def transaction_queries: () -> PgEventstore::TransactionQueries
+    def union_builders: (::Array[SQLBuilder] builders) -> SQLBuilder
 
-    def links_resolver: () -> PgEventstore::LinksResolver
+    def transaction_queries: () -> TransactionQueries
 
-    # _@param_ `hash`
-    def deserialize: (::Hash[untyped, untyped] hash) -> ::Hash[untyped, untyped]
+    def links_resolver: () -> LinksResolver
 
-    # _@param_ `attrs`
-    def find_by_attrs_builder: (::Hash[untyped, untyped] attrs) -> PgEventstore::SQLBuilder
+    def deserialize: (::Hash[String, untyped] hash) -> ::Hash[Symbol, untyped]
 
-    # Returns the value of attribute connection.
-    attr_accessor connection: PgEventstore::Connection
+    def find_by_attrs_builder: (::Hash[untyped, untyped] attrs) -> SQLBuilder
   end
 end

data/sig/pg_eventstore/subscriptions/replica_subscription_handler.rbs

@@ -0,0 +1,33 @@
+module PgEventstore
+  class ReplicaSubscriptionHandler
+    @replica_config_name: Symbol
+    @config_name: Symbol
+
+    def call: (Array[EventGlobalIndex::SubscriptionRepr] indexes) -> void
+
+    def initialize: (Symbol, Symbol) -> void
+
+    private
+
+    def connection: -> Connection
+
+    def destination_replica_queries: -> ReplicaQueries
+
+    def records_to_sql: (
+        String table_name, 
+        Array[Symbol] attribute_names, 
+        Array[Hash[Symbol, untyped]] attributes_collection, 
+        ?on_conflict: String?
+      ) -> String
+
+    def reject_already_processed: (
+        Array[EventGlobalIndex::SubscriptionRepr] indexes
+      ) -> Array[EventGlobalIndex::SubscriptionRepr]
+
+    def replica_connection: -> Connection
+
+    def replica_transaction_queries: -> TransactionQueries
+
+    def source_replica_queries: -> ReplicaQueries
+  end
+end

data/sig/pg_eventstore/subscriptions/replica_subscription_runner.rbs

@@ -0,0 +1,4 @@
+module PgEventstore
+  class ReplicaSubscriptionRunner < SubscriptionRunner
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feed_strategy/collection.rbs

@@ -0,0 +1,14 @@
+module PgEventstore
+  module SubscriptionFeedStrategy[unchecked Runner]
+    class Collection < Array[SubscriptionFeedStrategy[SubscriptionRunner] | SubscriptionFeedStrategy[ReplicaSubscriptionRunner]]
+      DEFAULT_SUBSCRIPTIONS_NUM_PER_QUERY: Integer
+
+      def self.create: (
+          Array[SubscriptionRunner | ReplicaSubscriptionRunner] runners,
+          Connection connection,
+          QueryStrategy query_strategy,
+          ?subscriptions_per_query: Integer
+        ) -> Collection
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feed_strategy/index_read_strategy.rbs

@@ -0,0 +1,23 @@
+module PgEventstore
+  module SubscriptionFeedStrategy[unchecked Runner]
+    class IndexReadStrategy
+      include SubscriptionFeedStrategy[SubscriptionRunner]
+
+      INDEX_LOOK_UP_DISTANCE: Integer
+
+      @connection: Connection
+      @query_strategy: QueryStrategy
+      @runners: Array[SubscriptionRunner]
+
+      def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+      private
+
+      def event_subscription_position_queries: -> EventSubscriptionPositionQueries
+
+      def events_global_index_queries: -> EventsGlobalIndexQueries
+
+      def safe_position: -> Integer
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feed_strategy/replication_strategy.rbs

@@ -0,0 +1,23 @@
+module PgEventstore
+  module SubscriptionFeedStrategy[unchecked Runner]
+    class ReplicationStrategy
+      include SubscriptionFeedStrategy[ReplicaSubscriptionRunner]
+
+      INDEX_LOOK_UP_DISTANCE: Integer
+
+      @connection: Connection
+      @query_strategy: QueryStrategy
+      @runners: Array[ReplicaSubscriptionRunner]
+
+      def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+      private
+
+      def event_subscription_position_queries: -> EventSubscriptionPositionQueries
+
+      def events_global_index_queries: -> EventsGlobalIndexQueries
+
+      def safe_position: -> Integer
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feed_strategy.rbs

@@ -0,0 +1,11 @@
+module PgEventstore
+  module SubscriptionFeedStrategy[unchecked Runner]
+    def add: (*Runner runners) -> Array[Runner]
+
+    def any?: -> bool
+
+    def feed: -> void
+
+    def size: -> Integer
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feeder.rbs

@@ -4,26 +4,27 @@ module PgEventstore
 
     extend Forwardable
 
-    @basic_runner: PgEventstore::BasicRunner
-    @commands_handler: PgEventstore::CommandsHandler
-    @subscriptions_lifecycle: PgEventstore::SubscriptionsLifecycle
-    @subscriptions_set_lifecycle: PgEventstore::SubscriptionsSetLifecycle
+    @basic_runner: BasicRunner
+    @commands_handler: CommandsHandler
+    @events_subscription_position_worker: EventsSubscriptionPositionWorker?
+    @subscriptions_lifecycle: SubscriptionsLifecycle
+    @subscriptions_set_lifecycle: SubscriptionsSetLifecycle
 
     attr_reader config_name: Symbol
 
     def initialize: (
         config_name: Symbol,
-        subscriptions_set_lifecycle: PgEventstore::SubscriptionsSetLifecycle,
-        subscriptions_lifecycle: PgEventstore::SubscriptionsLifecycle
+        subscriptions_set_lifecycle: SubscriptionsSetLifecycle,
+        subscriptions_lifecycle: SubscriptionsLifecycle
       ) -> void
 
-    def id: () -> Integer?
+    def id: -> Integer?
 
-    def start_all: () -> void
+    def start_all: -> void
 
-    def stop_all: () -> void
+    def stop_all: -> void
 
-    def attach_runner_callbacks: () -> void
+    def attach_runner_callbacks: -> void
 
     private
 
@@ -31,5 +32,7 @@ module PgEventstore
         Symbol config_name,
         SubscriptionsSetLifecycle subscriptions_set_lifecycle
       ) -> Array[RunnerRecoveryStrategy]
+
+    def requires_subscription_position_assignment?: -> bool
   end
 end

data/sig/pg_eventstore/subscriptions/subscription_handler_performance.rbs

@@ -5,7 +5,7 @@ module PgEventstore
 
     def initialize: () -> void
 
-    def track_exec_time: () { () -> untyped } -> untyped
+    def track_exec_time: (Integer events_number) { () -> untyped } -> untyped
 
     def average_event_processing_time: () -> Float
   end

data/sig/pg_eventstore/subscriptions/subscription_runner.rbs

@@ -1,9 +1,14 @@
 module PgEventstore
   class SubscriptionRunner
     extend Forwardable
-    MAX_EVENTS_PER_CHUNK: Integer
+    DEFAULT_MAX_EVENTS_PER_CHUNK: Integer
     MIN_EVENTS_PER_CHUNK: Integer
-    INITIAL_EVENTS_PER_CHUNK: Integer
+    DEFAULT_INITIAL_EVENTS_PER_CHUNK: Integer
+
+    @events_processor: EventsProcessor
+    @initial_events_per_chunk: Integer
+    @max_events_per_chunk: Integer
+    @stats: SubscriptionHandlerPerformance
 
     # Returns the value of attribute subscription.
     attr_reader subscription: Subscription
@@ -12,13 +17,12 @@ module PgEventstore
         stats: SubscriptionHandlerPerformance,
         events_processor: EventsProcessor,
         subscription: Subscription,
-        position_evaluation: SubscriptionPositionEvaluation,
+        ?initial_events_per_chunk: Integer,
+        ?max_events_per_chunk: Integer,
       ) -> void
 
     def next_chunk_query_opts: () -> ::Hash[untyped, untyped]
 
-    def next_chunk_safe?: -> bool
-
     def time_to_feed?: () -> bool
 
     def next_chunk_global_position: () -> Integer
@@ -26,5 +30,9 @@ module PgEventstore
     def estimate_events_number: () -> Integer
 
     def attach_callbacks: () -> void
+
+    private
+
+    def subscription_from_position: -> Integer
   end
 end

data/sig/pg_eventstore/subscriptions/subscription_runners_feeder.rbs

@@ -1,13 +1,13 @@
 module PgEventstore
   class SubscriptionRunnersFeeder
-    # _@param_ `config_name`
+    @config_name: Symbol
+
     def initialize: (Symbol config_name) -> void
 
-    # _@param_ `runners`
-    def feed: (::Array[PgEventstore::SubscriptionRunner] runners) -> void
+    def feed: (::Array[SubscriptionRunner] runners) -> void
 
-    def connection: () -> PgEventstore::Connection
+    private
 
-    def subscription_queries: () -> PgEventstore::SubscriptionQueries
+    def connection: -> Connection
   end
 end

data/sig/pg_eventstore/subscriptions/subscriptions_lifecycle.rbs

@@ -4,15 +4,15 @@ module PgEventstore
 
     @config_name: Symbol
 
-    @subscriptions_set_lifecycle: PgEventstore::SubscriptionsSetLifecycle
+    @subscriptions_set_lifecycle: SubscriptionsSetLifecycle
 
     @subscriptions_pinged_at: Time
 
     @force_lock: bool
 
-    attr_reader runners: Array[PgEventstore::SubscriptionRunner]
+    attr_reader runners: Array[SubscriptionRunner]
 
-    def initialize: (Symbol config_name, PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle, ?force_lock: bool)-> void
+    def initialize: (Symbol config_name, SubscriptionsSetLifecycle subscriptions_set_lifecycle, ?force_lock: bool)-> void
 
     def force_locked?: -> bool
 
@@ -20,8 +20,6 @@ module PgEventstore
 
     def ping_subscriptions: -> void
 
-    def subscriptions: -> Array[PgEventstore::Subscription]
-
-    def force_lock!: -> void
+    def subscriptions: -> Array[Subscription]
   end
 end

data/sig/pg_eventstore/subscriptions/subscriptions_manager.rbs

@@ -3,46 +3,36 @@ module PgEventstore
     extend Forwardable
 
     @set_name: String
-    @subscription_feeder: PgEventstore::SubscriptionFeeder
-    @subscriptions_lifecycle: PgEventstore::SubscriptionsLifecycle
-    @subscriptions_set_lifecycle: PgEventstore::SubscriptionsSetLifecycle
-
-    def self.callbacks: () -> PgEventstore::Callbacks
-
-    # _@param_ `config`
-    #
-    # _@param_ `set_name`
-    #
-    # _@param_ `max_retries` — max number of retries of failed SubscriptionsSet
-    #
-    # _@param_ `retries_interval` — a delay between retries of failed SubscriptionsSet
+    @subscription_feeder: SubscriptionFeeder
+    @subscriptions_lifecycle: SubscriptionsLifecycle
+    @subscriptions_set_lifecycle: SubscriptionsSetLifecycle
+
+    def self.callbacks: () -> Callbacks
+
     def initialize: (
-        config: PgEventstore::Config,
+        config: Config,
         set_name: String,
         ?max_retries: Integer?,
         ?retries_interval: Integer?,
         ?force_lock: bool
       ) -> void
 
+    def create_replication: (
+        String subscription_name,
+        Symbol primary_config_name,
+        ?options: ::Hash[untyped, untyped],
+        ?max_events_to_replicate: Integer,
+        ?pull_interval: Integer | Float,
+        ?max_retries: Integer,
+        ?retries_interval: Integer | Float,
+        ?restart_terminator: _RestartTerminator?,
+        ?failed_subscription_notifier: _FailedSubscriptionNotifier?,
+        ?graceful_shutdown_timeout: Integer | Float,
+        ?in_batches: bool,
+      ) -> void
+
     def config_name: () -> Symbol
 
-    # _@param_ `subscription_name` — subscription's name
-    #
-    # _@param_ `handler` — subscription's handler
-    #
-    # _@param_ `options` — request options
-    #
-    # _@param_ `middlewares` — provide a list of middleware names to override a config's middlewares
-    #
-    # _@param_ `pull_interval` — an interval in seconds to determine how often to query new events of the given subscription.
-    #
-    # _@param_ `max_retries` — max number of retries of failed Subscription
-    #
-    # _@param_ `retries_interval` — a delay between retries of failed Subscription
-    #
-    # _@param_ `restart_terminator` — a callable object which is invoked with PgEventstore::Subscription instance to determine whether restarts should be stopped(true - stops restarts, false - continues restarts)
-    #
-    # _@param_ `failed_subscription_notifier` - a callable object which is invoked with PgEventstore::Subscription instance and error instance after the related subscription died due to error and no longer can be automatically restarted due to max retries number reached. You can use this hook to send a notification about failed subscription.
     def subscribe: (
         String subscription_name,
         handler: _SubscriptionHandler,
@@ -54,26 +44,22 @@ module PgEventstore
         ?restart_terminator: _RestartTerminator?,
         ?failed_subscription_notifier: _FailedSubscriptionNotifier?,
         ?graceful_shutdown_timeout: Integer | Float,
+        ?in_batches: bool,
       ) -> void
 
-    def subscriptions: () -> ::Array[PgEventstore::Subscription]
+    def subscriptions: () -> ::Array[Subscription]
 
-    def subscriptions_set: () -> PgEventstore::SubscriptionsSet?
+    def subscriptions_set: () -> SubscriptionsSet?
 
-    # _@param_ `middlewares`
-    #
-    # _@param_ `handler`
-    def create_raw_event_handler: (::Array[Symbol]? middlewares, _SubscriptionHandler handler) -> _RawEventHandler
+    def deserializer: (::Array[Symbol]? middlewares) -> EventDeserializer
 
-    # _@param_ `middlewares`
-    def select_middlewares: (?::Array[Symbol]? middlewares) -> ::Array[PgEventstore::Middleware]
+    def select_middlewares: (?::Array[Symbol]? middlewares) -> ::Array[Middleware]
 
-    def start!: () -> PgEventstore::BasicRunner
+    def start!: () -> BasicRunner
 
-    def start: () -> PgEventstore::BasicRunner?
+    def start: () -> BasicRunner?
 
-    # Returns the value of attribute config.
-    attr_accessor config: PgEventstore::Config
+    attr_accessor config: Config
 
     private
 

data/sig/pg_eventstore/synchronized_array.rbs

@@ -0,0 +1,4 @@
+module PgEventstore
+  class SynchronizedArray[unchecked out Elem] < Array[Elem]
+  end
+end

data/sig/pg_eventstore/utils.rbs

@@ -1,28 +1,35 @@
 module PgEventstore
   class Utils
-    # _@param_ `object`
-    def self.deep_transform_keys: (untyped object) { (untyped key) -> untyped } -> Object
+    def self.assert!: (boolish truthy, String? message) -> void
 
-    # _@param_ `object`
-    def self.deep_dup: (untyped object) -> Object
+    def self.assert_node_role!: (Config config, Array[Symbol] expected_roles) -> void
+
+    def self.benchmark: { -> untyped } -> Float
+
+    def self.deep_transform_keys: (untyped object) { (untyped key) -> untyped } -> untyped
+
+    def self.deep_dup: (untyped object) -> untyped
 
     def self.deprecation_warning: (String message) -> void
 
-    # _@param_ `array`
-    #
-    # _@return_ — positional variables, based on array size. Example: "$1, $2, $3"
+    def self.missing_implementation!: (untyped obj) -> void
+
     def self.positional_vars: (::Array[untyped] array) -> String
 
-    # _@param_ `error`
     def self.error_info: (StandardError error) -> ::Hash[untyped, untyped]
 
-    # _@param_ `str`
+    def self.read_pid: (String file_path) -> String?
+
+    def self.remove_file: (String file_path) -> void
+
     def self.underscore_str: (String str) -> String
 
     def self.original_global_position: (Hash[untyped, untyped] raw_event) -> Integer
 
-    def self.unwrap_exception: (PgEventstore::WrappedException | StandardError wrapped_exception)-> StandardError
+    def self.unwrap_exception: (WrappedException | StandardError wrapped_exception) -> StandardError
+
+    def self.wrap_exception: (StandardError exception, **untyped extra) -> WrappedException
 
-    def self.wrap_exception: (StandardError exception, **untyped extra)-> PgEventstore::WrappedException
+    def self.write_to_file: (String file_path, String content) -> void
   end
 end

data/sig/pg_eventstore/web/application.rbs

@@ -11,7 +11,7 @@ module PgEventstore
 
       def asset_url: (String path) -> String
 
-      def connection: -> PgEventstore::Connection
+      def connection: -> Connection
 
       def current_config: -> Symbol
 
@@ -19,13 +19,15 @@ module PgEventstore
 
       def escape_empty_string: (String? string) -> String?
 
-      def events_filter: -> Array[String]?
+      def events_filter: -> Array[String | Hash[untyped, untyped]]
 
       def flash_message=: (({ message: String, kind: String }) val)-> String
 
       def h: (String text) -> String
 
-      def paginated_json_response: (PgEventstore::Web::Paginator::BaseCollection collection) -> void
+      def markers_filter: -> Array[String]
+
+      def paginated_json_response: (Paginator::BaseCollection collection) -> void
 
       def redirect_back_url: (fallback_url: String) -> String
 
@@ -38,6 +40,14 @@ module PgEventstore
       def system_stream: -> String?
 
       def unescape_empty_string: (String? string) -> String?
+
+      def extract_event_types_filter: (Hash[untyped, untyped] options) -> Array[String | Hash[untyped, untyped]]
+
+      def extract_streams_filter: (Hash[untyped, untyped] options) -> Array[Hash[untyped, untyped]]
+
+      private
+
+      def normalize_markers: (Hash[untyped, untyped] hash) -> Array[String]
     end
   end
 end

data/sig/pg_eventstore/web/paginator/base_collection.rbs

@@ -2,6 +2,8 @@ module PgEventstore
   module Web
     module Paginator
       class BaseCollection
+        MIN_QUERY_SIZE_FOR_ADVANCE_SEARCH: Integer
+
         def initialize: (
             Symbol config_name,
             starting_id: (String | Integer)?,