zizq 0.2.1 → 0.3.0

data/lib/zizq.rb

@@ -12,20 +12,24 @@ require_relative "zizq/configuration"
 autoload :MessagePack, "msgpack"
 
 module Zizq
-  autoload :AckProcessor,    "zizq/ack_processor"
-  autoload :ActiveJobConfig, "zizq/active_job_config"
-  autoload :Backoff,         "zizq/backoff"
-  autoload :BulkEnqueue,     "zizq/bulk_enqueue"
-  autoload :Client,          "zizq/client"
-  autoload :EnqueueRequest,  "zizq/enqueue_request"
-  autoload :EnqueueWith,     "zizq/enqueue_with"
-  autoload :Job,             "zizq/job"
-  autoload :JobConfig,       "zizq/job_config"
-  autoload :Middleware,      "zizq/middleware"
-  autoload :Lifecycle,       "zizq/lifecycle"
-  autoload :Query,           "zizq/query"
-  autoload :Resources,       "zizq/resources"
-  autoload :Worker,          "zizq/worker"
+  autoload :AckProcessor,        "zizq/ack_processor"
+  autoload :ActiveJobConfig,     "zizq/active_job_config"
+  autoload :Backoff,             "zizq/backoff"
+  autoload :BulkEnqueue,         "zizq/bulk_enqueue"
+  autoload :Client,              "zizq/client"
+  autoload :Crontab,             "zizq/crontab"
+  autoload :CrontabBuilder,      "zizq/crontab_builder"
+  autoload :CrontabEntry,        "zizq/crontab_entry"
+  autoload :CrontabEntryBuilder, "zizq/crontab_entry_builder"
+  autoload :EnqueueRequest,      "zizq/enqueue_request"
+  autoload :EnqueueWith,         "zizq/enqueue_with"
+  autoload :Job,                 "zizq/job"
+  autoload :JobConfig,           "zizq/job_config"
+  autoload :Middleware,          "zizq/middleware"
+  autoload :Lifecycle,           "zizq/lifecycle"
+  autoload :Query,               "zizq/query"
+  autoload :Resources,           "zizq/resources"
+  autoload :Worker,              "zizq/worker"
 
   # Sentinel indicating a field should not be included in the request.
   # Used as the default for update parameters.
@@ -59,7 +63,9 @@ module Zizq
     def configure #: () { (Configuration) -> void } -> void
       yield configuration
     ensure
-      @client = nil # shared client is potentially stale
+      # shared client is potentially stale
+      @client&.close
+      @client = nil
     end
 
     # Returns a shared client instance built from the global configuration.
@@ -114,6 +120,88 @@ module Zizq
       Query.new(...)
     end
 
+    # Return a list of all available Crontab schedules.
+    def crontabs #: () -> Array[String]
+      Zizq.client.list_cron_groups
+    end
+
+    # Define (or redefine) a Crontab schedule.
+    #
+    # This requires a Pro license on the Zizq server.
+    #
+    # Crontabs are used to define collections of recurring jobs that run on a
+    # specified schedule, such as at 2am on every Monday. Each entry on the
+    # Crontab is a single job enqueue, which the Zizq server automatically
+    # triggers at the correct point in time. Zizq uses standard Cron expression
+    # syntax (with support for seconds via 6-fields) to define entries.
+    #
+    # This is designed to be idempotent. You can define a schedule somewhere in
+    # your application startup process (after `Zizq.configure`) and it doesn't
+    # matter if multiple process all define the same schedule. Zizq is smart
+    # enough to handle this correctly.
+    #
+    # Entire schedules, and individual entries on a schedule, can be paused and
+    # resumed.
+    #
+    # By default schedules operate in the system time zone of the Zizq server
+    # but an explicit IANA timezone name can be specified when defining the
+    # Crontab.
+    #
+    # This method sends exactly *one* request to the Zizq server upon
+    # completion of the block. Any existing entries are retained. Any new
+    # entries are added, any absent entries are removed, and any modified
+    # entries are replaced. In short, whatever the block defines is what the
+    # entire resulting Crontab schedule will look like.
+    #
+    #   Zizq.define_crontab("example", timezone: "Europe/Rome") do |cron|
+    #     cron.define_entry(
+    #       "refresh_data_warehose",
+    #       "*/15 * * * *"
+    #     ).enqueue(RefreshDataWarehoseJob, incremental: true)
+    #
+    #     cron.define_entry(
+    #       "expire_acess_tokens",
+    #       "*/10 * * * * *"
+    #     ).enqueue_raw(
+    #       queue: "identity-server",
+    #       type: "expire_access_tokens",
+    #       priority: 100,
+    #       payload: {},
+    #     )
+    #   end
+    #
+    # When jobs are pushed to the queue at their execution time, Zizq handles
+    # this atomically, so there is no risk of a duplicate enqueue for the same
+    # schedule tick. However, if you have long-running jobs that should not be
+    # permitted to overlap, such as in the case your schedule runs every 10
+    # seconds but jobs can take 30 seconds to execute, you should consider
+    # using unique jobs.
+    #
+    # @rbs name: String
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    # @rbs &block: (Zizq::CrontabBuilder) -> void
+    # @rbs return: Zizq::Crontab
+    def define_crontab(name, timezone: nil, paused: nil, &block)
+      crontab = Crontab.new(name)
+      crontab.redefine(timezone:, paused:, &block)
+      crontab
+    end
+
+    # Obtain a handle for the given Crontab schedule.
+    #
+    # This is a lazy operation. The schedule data is only fetched from the Zizq
+    # server upon first accessing data within the schedule.
+    #
+    #   Zizq.crontab("default").paused?
+    #   Zizq.crontab("default").resume!
+    #
+    # @rbs name: String
+    # @rbs return: Zizq::Crontab
+    def crontab(name)
+      Crontab.new(name)
+    end
+
     # Enqueue a job by class with positional and keyword arguments.
     #
     # By default all arguments are serialized as JSON, which means hashes with
@@ -149,7 +237,7 @@ module Zizq
     #     end
     #   end
     #
-    # @rbs job_class: Class & Zizq::job_class
+    # @rbs job_class: Class & Zizq::JobConfig
     # @rbs args: Array[untyped]
     # @rbs kwargs: Hash[Symbol, untyped]
     # @rbs &block: ?(EnqueueRequest) -> void
@@ -247,7 +335,7 @@ module Zizq
     # @api private
     # Build an EnqueueRequest for a single job class enqueue.
     #
-    # @rbs job_class: Class & Zizq::job_class
+    # @rbs job_class: Class & Zizq::JobConfig
     # @rbs args: Array[untyped]
     # @rbs kwargs: Hash[Symbol, untyped]
     # @rbs &block: ?(EnqueueRequest) -> void
@@ -257,7 +345,7 @@ module Zizq
         raise ArgumentError, "#{job_class.inspect} must include Zizq::Job or extend Zizq::ActiveJobConfig"
       end
 
-      zizq_job_class = job_class #: Zizq::job_class
+      zizq_job_class = job_class #: Zizq::JobConfig
       req = zizq_job_class.zizq_enqueue_request(*args, **kwargs)
       yield req if block_given?
       req

data/sig/generated/zizq/bulk_enqueue.rbs

@@ -16,12 +16,12 @@ module Zizq
     # Collect a job class enqueue. Accepts the same arguments as
     # `Zizq.enqueue`.
     #
-    # @rbs job_class: Class & Zizq::job_class
+    # @rbs job_class: Class & Zizq::JobConfig
     # @rbs args: Array[untyped]
     # @rbs kwargs: Hash[Symbol, untyped]
     # @rbs &block: ?(EnqueueRequest) -> void
     # @rbs return: void
-    def enqueue: (Class & Zizq::job_class job_class, *untyped args, **untyped kwargs) ?{ (EnqueueRequest) -> void } -> void
+    def enqueue: (Class & Zizq::JobConfig job_class, *untyped args, **untyped kwargs) ?{ (EnqueueRequest) -> void } -> void
 
     # Collect a raw enqueue. Accepts the same arguments as
     # `Zizq.enqueue_raw`.

data/sig/generated/zizq/client.rbs

@@ -196,6 +196,90 @@ module Zizq
     # List all distinct queue names on the server.
     def get_queues: () -> untyped
 
+    # List all cron group names.
+    #
+    # @rbs return: Array[String]
+    def list_cron_groups: () -> Array[String]
+
+    # Fetch a cron group and all its entries.
+    #
+    # @rbs name: String
+    # @rbs return: Resources::CronGroup
+    def get_cron_group: (String name) -> Resources::CronGroup
+
+    # Create or replace an entire cron group.
+    #
+    # Entries not present in the request are removed. Entries with unchanged
+    # expressions preserve their scheduling state.
+    #
+    # @rbs name: String
+    # @rbs paused: bool?
+    # @rbs entries: Array[Zizq::cron_entry_params]
+    # @rbs return: Resources::CronGroup
+    def replace_cron_group: (String name, ?paused: bool?, ?entries: Array[Zizq::cron_entry_params]) -> Resources::CronGroup
+
+    # Update group-level fields (currently just pause/unpause).
+    #
+    # @rbs name: String
+    # @rbs paused: bool?
+    # @rbs return: Resources::CronGroup
+    def update_cron_group: (String name, ?paused: bool?) -> Resources::CronGroup
+
+    # Delete a cron group and all its entries.
+    #
+    # @rbs name: String
+    # @rbs return: void
+    def delete_cron_group: (String name) -> void
+
+    # Fetch a single cron entry.
+    #
+    # @rbs group: String
+    # @rbs entry: String
+    # @rbs return: Resources::CronEntry
+    def get_cron_group_entry: (String group, String entry) -> Resources::CronEntry
+
+    # Add a single entry to a cron group (creates the group if needed).
+    #
+    # Raises a ClientError (409 Conflict) if an entry with the same name
+    # already exists.
+    #
+    # @rbs group: String
+    # @rbs name: String
+    # @rbs expression: String
+    # @rbs job: Zizq::cron_job_params
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    # @rbs return: Resources::CronEntry
+    def add_cron_group_entry: (String group, name: String, expression: String, job: Zizq::cron_job_params, ?timezone: String?, ?paused: bool?) -> Resources::CronEntry
+
+    # Create or replace a single cron entry.
+    #
+    # Preserves scheduling state if the expression is unchanged.
+    #
+    # @rbs group: String
+    # @rbs entry: String
+    # @rbs expression: String
+    # @rbs job: Zizq::cron_job_params
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    # @rbs return: Resources::CronEntry
+    def replace_cron_group_entry: (String group, String entry, expression: String, job: Zizq::cron_job_params, ?timezone: String?, ?paused: bool?) -> Resources::CronEntry
+
+    # Update entry-level fields (currently just pause/unpause).
+    #
+    # @rbs group: String
+    # @rbs entry: String
+    # @rbs paused: bool
+    # @rbs return: Resources::CronEntry
+    def update_cron_group_entry: (String group, String entry, paused: bool) -> Resources::CronEntry
+
+    # Delete a single cron entry.
+    #
+    # @rbs group: String
+    # @rbs entry: String
+    # @rbs return: void
+    def delete_cron_group_entry: (String group, String entry) -> void
+
     # Mark a job as successfully completed (ack).
     #
     # If this method (or [`#report_failure`]) is not called upon job
@@ -330,9 +414,38 @@ module Zizq
 
     private
 
+    # URL-encode a single path segment.
+    def enc: (untyped value) -> untyped
+
     # Build a relative path with optional query parameters.
     def build_path: (untyped path, ?params: untyped) -> untyped
 
+    # Validate and build a cron entry body from keyword arguments.
+    #
+    # @rbs name: String
+    # @rbs expression: String
+    # @rbs job: Zizq::cron_job_params
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    # @rbs return: Hash[Symbol, untyped]
+    def build_cron_entry: (?name: String, ?expression: String, ?job: Zizq::cron_job_params, ?timezone: String?, ?paused: bool?) -> Hash[Symbol, untyped]
+
+    # Validate and build a cron job template from keyword arguments.
+    #
+    # Uses keyword args so that unknown keys raise ArgumentError.
+    #
+    # @rbs type: String
+    # @rbs queue: String
+    # @rbs payload: untyped
+    # @rbs priority: Integer?
+    # @rbs retry_limit: Integer?
+    # @rbs backoff: Zizq::backoff?
+    # @rbs retention: Zizq::retention?
+    # @rbs unique_key: String?
+    # @rbs unique_while: Zizq::unique_scope?
+    # @rbs return: Hash[Symbol, untyped]
+    def build_cron_job: (?type: String, ?queue: String, ?payload: untyped, ?priority: Integer?, ?retry_limit: Integer?, ?backoff: Zizq::backoff?, ?retention: Zizq::retention?, ?unique_key: String?, ?unique_while: Zizq::unique_scope?) -> Hash[Symbol, untyped]
+
     # Validate and normalize filter parameters for bulk operations.
     #
     # Uses keyword arguments so that unknown keys raise ArgumentError.
@@ -419,6 +532,8 @@ module Zizq
 
     def raw_post: (untyped path) -> untyped
 
+    def put: (untyped path, untyped body) -> untyped
+
     def delete: (untyped path, ?params: untyped) -> untyped
 
     def patch: (untyped path, untyped body, ?params: untyped) -> untyped

data/sig/generated/zizq/crontab.rbs

@@ -0,0 +1,141 @@
+# Generated from lib/zizq/crontab.rb with RBS::Inline
+
+module Zizq
+  # Represents a Crontab schedule defined on the Zizq server.
+  #
+  # This requires a Pro license on the Zizq server.
+  #
+  # The actual data is lazily fetched when first accessed.
+  #
+  # Crontabs are used to define collections of recurring jobs that run on a
+  # specified schedule, such as at 2am on every Monday. Each entry on the
+  # Crontab is a single job enqueue, which the Zizq server automatically
+  # triggers at the correct point in time. Zizq uses standard Cron expression
+  # syntax (with support for seconds via 6-fields) to define entries.
+  #
+  # Entire schedules, and individual entries on a schedule, can be paused and
+  # resumed.
+  #
+  # By default schedules operate in the system time zone of the Zizq server
+  # but an explicit IANA timezone name can be specified when defining the
+  # Crontab.
+  class Crontab
+    # The name of the cron group that this schedule is backed by.
+    attr_reader name: String
+
+    # True if this schedule is paused.
+    #
+    # When paused, the scheduler continues to run but does not enqueue any jobs
+    # and only advances the timer.
+    attr_writer paused: bool?
+
+    # Initialize the Crontab with the given group name.
+    #
+    # @rbs name: String
+    def initialize: (String name) -> untyped
+
+    # Fetch data from the Zizq server if not already fetched.
+    #
+    # Once fetched, this method becomes a no-op, unless #clear is called to
+    # remove the fetched data.
+    def materialize: () -> untyped
+
+    # Clear materialized data that was fetched from the Zizq server.
+    #
+    # This triggers a refetch when the data is next accessed.
+    def clear: () -> untyped
+
+    # Delete this entire Crontab schedule and its entries.
+    def delete!: () -> untyped
+
+    # Pause this entire Crontab schedule.
+    #
+    # All entries will stop enqueueing jobs, but the server continues to
+    # advance the schedule until it is resumed.
+    def pause!: () -> untyped
+
+    # Resume this Crontab schedule if it is currently paused.
+    #
+    # Individual entries that are paused will remain paused.
+    def resume!: () -> untyped
+
+    # Check if this schedule is currently paused.
+    def paused: () -> untyped
+
+    # Check if this schedule is currently paused.
+    #
+    # Alias of #paused.
+    def paused?: () -> untyped
+
+    # Return the timestamp at which this Crontab schedule was last paused.
+    def paused_at: () -> untyped
+
+    # Return the timestamp at which this Crontab schedule was last resumed.
+    def resumed_at: () -> untyped
+
+    # Return a Hash of Zizq::CrontabEntry instances keyed by their names.
+    #
+    # Each entry specifies the cron expression at which it executes,
+    # information about when it last/next enqueued a job, and details of the
+    # job that the entry enqueues.
+    def entries: () -> untyped
+
+    # Redefine (replace) this Crontab schedule with another.
+    #
+    # This is equivalent to calling `Zizq.define_crontab` and is idempotent
+    # when given the same schedule more than once.
+    #
+    # @rbs ?timezone: String?
+    # @rbs ?paused: bool?
+    # @rbs &block: (Zizq::CrontabBuilder) -> void
+    # @rbs return: self
+    def redefine: (?timezone: untyped, ?paused: untyped) { (Zizq::CrontabBuilder) -> void } -> self
+
+    # Return a handle for the specified Zizq::CrontabEntry.
+    #
+    # The entry can be paused or resumed is isolation, can be deleted entirely
+    # or can be redefined (replaced) with another entry.
+    #
+    # @rbs name: String
+    # @rbs return: Zizq::CrontabEntry
+    def entry: (String name) -> Zizq::CrontabEntry
+
+    # Define (or redefine) an entry with this Crontab schedule.
+    #
+    # Defining the same entry more than once is idempotent. If the entry does
+    # not exist, it is added to the schedule. If the entry already exists, it
+    # replaces the current entry.
+    #
+    # The return value is a Zizq::CrontabEntryBuilder instance, on which the
+    # caller must call one of the enqueue methods (`enqueue`, `enqueue_raw`,
+    # optionally chained onto `enqueue_with`, exactly the same as a regular job
+    # enqueue).
+    #
+    # All enqueue options are supported *except* `delay` and `ready_at` which
+    # make no sense for recurring jobs.
+    #
+    # Bulk enqueues are not supported.
+    #
+    #   crontab.define_entry(
+    #     "refresh_data_warehose",
+    #     "*/15 * * * *",
+    #   ).enqueue(RefreshDataWarehoseJob, incremental: true)
+    #
+    # @rbs name: String
+    # @rbs expression: String
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    # @rbs return: Zizq::CrontabEntryBuilder
+    def define_entry: (String name, String expression, ?timezone: String?, ?paused: bool?) -> Zizq::CrontabEntryBuilder
+
+    private
+
+    # @rbs result: Zizq::Resources::CronGroup
+    # @rbs return: self
+    def materialize_with: (Zizq::Resources::CronGroup result) -> self
+
+    # @rbs result: Zizq::Resources::CronEntry
+    # @rbs return: Zizq::CrontabEntry
+    def materialize_entry_with: (Zizq::Resources::CronEntry result) -> Zizq::CrontabEntry
+  end
+end

data/sig/generated/zizq/crontab_builder.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/zizq/crontab_builder.rb with RBS::Inline
+
+module Zizq
+  # Builder used to configure a Zizq::Crontab instance.
+  #
+  # Instances of this class are returned from `Zizq.define_crontab`. See
+  # documentation for that method for usage.
+  class CrontabBuilder
+    # The Crontab instance that this builder configures.
+    attr_reader target: Zizq::Crontab
+
+    # Optional timezone to be applied to all entries by default.
+    attr_accessor timezone: String?
+
+    # Initialize the builder with the given Crontab instance.
+    #
+    # @rbs target: Zizq::Crontab
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    def initialize: (Zizq::Crontab target, ?timezone: String?, ?paused: bool?) -> untyped
+
+    # Add or replace an entry on the schedule
+    #
+    # If no entry with the given name exists, it is added to schedule. If an
+    # entry with the same name exist, this entry replaces that entry. If the
+    # entry is the same as the original, the result is idempotent.
+    #
+    # @rbs name: String
+    # @rbs expression: String
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    # @rbs return: Zizq::CrontabEntryBuilder
+    def define_entry: (String name, String expression, ?timezone: String?, ?paused: bool?) -> Zizq::CrontabEntryBuilder
+  end
+end

data/sig/generated/zizq/crontab_entry.rbs

@@ -0,0 +1,98 @@
+# Generated from lib/zizq/crontab_entry.rb with RBS::Inline
+
+module Zizq
+  # Represents a single entry within a Crontab schedule.
+  #
+  # Each entry specifies the cron expression at which it executes,
+  # information about when it last/next enqueued a job, and details of the
+  # job that the entry enqueues.
+  #
+  # Entries can be paused or resumed, and can be deleted or redefined in place.
+  class CrontabEntry
+    # The Crontab schedule to which this entry belongs.
+    attr_reader crontab: Zizq::Crontab
+
+    # The name of this entry within the schedule.
+    attr_reader name: String
+
+    # The cron expression used to define the schedule for the entry.
+    #
+    # Both standard 5-field and enhanced 6-field cron (with seconds) are
+    # supported, along with @daily, @weekly etc.
+    attr_reader expression: String
+
+    # The timezone in which the schedule entry is processed.
+    #
+    # Defaults to the Zizq server timezone unless specified.
+    attr_reader timezone: String?
+
+    # Parameters that will be used to enqueue jobs each time the schedule fires.
+    #
+    # These are the same parameters as those used to enqueue jobs normally.
+    attr_reader job: EnqueueRequest
+
+    # True if this entry is currrently paused.
+    attr_reader paused: bool?
+
+    # The timestamp at which this entry was last paused.
+    attr_reader paused_at: Float?
+
+    # The timestamp at which this entry was last resumed.
+    attr_reader resumed_at: Float?
+
+    # The timestamp at which a job was last enqueued for this entry.
+    attr_reader last_enqueue_at: Float?
+
+    #
+    #  The timestamp at which the next job will be enqueued for this entry.
+    attr_reader next_enqueue_at: Float?
+
+    # Initialize the entry with all configured parameters.
+    #
+    # @rbs crontab: Zizq::Crontab
+    # @rbs name: String
+    # @rbs expression: String
+    # @rbs timezone: String?
+    # @rbs job: EnqueueRequest
+    # @rbs paused: bool?
+    # @rbs paused_at: Float?
+    # @rbs resumed_at: Float?
+    # @rbs last_enqueue_at: Float?
+    # @rbs next_enqueue_at: Float?
+    def initialize: (Zizq::Crontab crontab, String name, String expression, job: EnqueueRequest, ?timezone: String?, ?paused: bool?, ?paused_at: Float?, ?resumed_at: Float?, ?last_enqueue_at: Float?, ?next_enqueue_at: Float?) -> untyped
+
+    # Replace this entry with another.
+    #
+    # This is equivalent to calling `crontab.define_entry` with the same name.
+    #
+    # @rbs expression: String
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    # @rbs return: Zizq::CrontabEntryBuilder
+    def redefine: (String expression, ?timezone: String?, ?paused: bool?) -> Zizq::CrontabEntryBuilder
+
+    # Delete the entry from the schedule.
+    def delete!: () -> untyped
+
+    # Pause the entry within the schedule.
+    #
+    # This is independent of the paused state of the Crontab itself.
+    def pause!: () -> untyped
+
+    # Resume this entry if it is currently paused.
+    #
+    # If the parent Crontab itself is paused, the entry will still not enqueue
+    # jobs until the Crontab is resumed.
+    def resume!: () -> untyped
+
+    # @private
+    # @rbs return: Zizq::cron_entry_params
+    def to_params: () -> Zizq::cron_entry_params
+
+    private
+
+    # @rbs result: Zizq::Resources::CronEntry
+    # @rbs return: self
+    def materialize_with: (Zizq::Resources::CronEntry result) -> self
+  end
+end

data/sig/generated/zizq/crontab_entry_builder.rbs

@@ -0,0 +1,92 @@
+# Generated from lib/zizq/crontab_entry_builder.rb with RBS::Inline
+
+module Zizq
+  # Builder class used to define individual entries within a Crontab schedule.
+  #
+  # This is used internally by `Zizq.define_crontab`. See documentation for
+  # that method for full details.
+  #
+  # Callers *must* call one of the enqueue methods to complete the build
+  # process.
+  class CrontabEntryBuilder
+    # The Crontab instance onto which entries are applied.
+    attr_reader target: Zizq::Crontab
+
+    # The name of the entry being built.
+    attr_reader name: String
+
+    # The cron expression for the entry.
+    attr_reader expression: String
+
+    # Optional timezone for the entry.
+    #
+    # Defaults to the Zizq server timezone when not specified.
+    attr_reader timezone: String?
+
+    # True if this entry will be paused.
+    attr_reader paused: bool?
+
+    # Callback through which the built entry is passed before being added to
+    # the Crontab schedule.
+    #
+    # The callback receives the Zizq::CrontabEntry instance and may return an
+    # alternative instance to be used after it has done any processing on the
+    # entry.
+    attr_reader callback: ^(Zizq::CrontabEntry) -> Zizq::CrontabEntry
+
+    # Initialize the builder with the given inputs.
+    #
+    # @rbs target: Zizq::Crontab
+    # @rbs name: String
+    # @rbs expression: String
+    # @rbs timezone: String?
+    # @rbs paused: bool?
+    # @rbs ?&block: (Zizq::CrontabEntry) -> Zizq::CrontabEntry
+    def initialize: (Zizq::Crontab target, String name, String expression, ?timezone: String?, ?paused: bool?) ?{ (?) -> untyped } -> untyped
+
+    # Enqueue a Zizq::Job or ActiveJob class using Zizq::ActiveJobConfig via
+    # this entry.
+    #
+    # @rbs job_class: Class & Zizq::JobConfig
+    # @rbs args: Array[untyped]
+    # @rbs kwargs: Hash[Symbol, untyped]
+    # @rbs &block: ?(EnqueueRequest) -> void
+    # @rbs return: void
+    def enqueue: (Class & Zizq::JobConfig job_class, *untyped args, **untyped kwargs) ?{ (EnqueueRequest) -> void } -> void
+
+    # Process a raw job enqueue for this entry.
+    #
+    # This is used for low-level or cross-language support.
+    #
+    # @rbs queue: String
+    # @rbs type: String
+    # @rbs payload: untyped
+    # @rbs priority: Integer?
+    # @rbs ready_at: Zizq::to_f?
+    # @rbs retry_limit: Integer?
+    # @rbs backoff: Zizq::backoff?
+    # @rbs retention: Zizq::retention?
+    # @rbs unique_key: String?
+    # @rbs unique_while: Zizq::unique_scope?
+    # @rbs return: void
+    def enqueue_raw: (queue: String, type: String, payload: untyped, **untyped opts) -> void
+
+    # Bulk enqueues are not supported via cron.
+    #
+    # @rbs &block: (BulkEnqueue) -> void
+    # @rbs return: self
+    def enqueue_bulk: () { (BulkEnqueue) -> void } -> self
+
+    # Provide common fields to be used when enqueueing a job.
+    #
+    # @rbs overrides: Hash[Symbol, untyped]
+    # @rbs return: EnqueueWith
+    def enqueue_with: (**untyped overrides) -> EnqueueWith
+
+    private
+
+    # @rbs job: EnqueueRequest
+    # @rbs return: untyped
+    def push_entry: (untyped req) -> untyped
+  end
+end