temporalio 1.6.0 → 1.7.0

data/rbi/temporalio/api/common/v1/message.rbi

@@ -486,6 +486,95 @@ class Temporalio::Api::Common::V1::WorkflowExecution
   end
 end
 
+# Identifies a specific execution within a namespace. This is used for standalone activities
+# executions in batch jobs currently.
+class Temporalio::Api::Common::V1::Execution
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      type: T.nilable(T.any(Symbol, String, Integer)),
+      business_id: T.nilable(String),
+      run_id: T.nilable(String)
+    ).void
+  end
+  def initialize(
+    type: :EXECUTION_TYPE_UNSPECIFIED,
+    business_id: "",
+    run_id: ""
+  )
+  end
+
+  sig { returns(T.any(Symbol, Integer)) }
+  def type
+  end
+
+  sig { params(value: T.any(Symbol, String, Integer)).void }
+  def type=(value)
+  end
+
+  sig { void }
+  def clear_type
+  end
+
+  sig { returns(String) }
+  def business_id
+  end
+
+  sig { params(value: String).void }
+  def business_id=(value)
+  end
+
+  sig { void }
+  def clear_business_id
+  end
+
+  sig { returns(String) }
+  def run_id
+  end
+
+  sig { params(value: String).void }
+  def run_id=(value)
+  end
+
+  sig { void }
+  def clear_run_id
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Temporalio::Api::Common::V1::Execution) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::Execution).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Execution) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::Execution, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
 # Represents the identifier used by a workflow author to define the workflow. Typically, the
 # name of a function. This is sometimes referred to as the workflow's "name"
 class Temporalio::Api::Common::V1::WorkflowType
@@ -1933,15 +2022,17 @@ class Temporalio::Api::Common::V1::OnConflictOptions
   end
 end
 
-# The configuration for time skipping of a workflow execution (a chain of runs including retries, cron, continue-as-new).
+# The configuration for time skipping of an execution.
 # When time skipping is enabled, virtual time advances automatically whenever there is no in-flight work.
-# In-flight work includes activities, child workflows, Nexus operations, signal/cancel external workflow operations,
-# and possibly other features added in the future.
-# User timers are not classified as in-flight work and will be skipped over; the virtual clock may also skip to the
-# time point of the registered fast forward when there is no in-flight work.
-# When time is skipped, a WorkflowExecutionTimeSkippingTransitionedEvent will be
-# added to the workflow history to capture the state changes.
+# Options like fast_forward, disable_propagation, and max_session_skip_count are provided for granular
+# control of the execution's time skipping behavior. See each field's comment for a detailed explanation.
 #
+# An example of workflows with time skipping:
+# For workflows, an execution is a chain of runs including retries, cron, and continue-as-new.
+# In-flight work includes activities, child workflows, Nexus operations, signal/cancel external workflow operations, etc.
+# User timers are not classified as in-flight work and will be skipped over; the virtual clock may also skip to the
+# time point of the registered fast-forward when there is no in-flight work.
+# Whenever time is skipped, the skip count is incremented by one; max_session_skip_count bounds the number of skips allowed within a single time-skipping session.
 # For child workflows, by default, if the parent execution is skipping time, the child execution will also skip time,
 # but a parent's fast_forward won't affect its child's execution. A flag is provided to disable propagation of the
 # "enabled" flag to child workflows; regardless of that flag, a child workflow inherits the virtual time from the
@@ -1953,14 +2044,16 @@ class Temporalio::Api::Common::V1::TimeSkippingConfig
   sig do
     params(
       enabled: T.nilable(T::Boolean),
-      fast_forward: T.nilable(Google::Protobuf::Duration),
-      disable_child_propagation: T.nilable(T::Boolean)
+      fast_forward_config: T.nilable(Temporalio::Api::Common::V1::FastForwardConfig),
+      disable_propagation: T.nilable(T::Boolean),
+      max_session_skip_count: T.nilable(Integer)
     ).void
   end
   def initialize(
     enabled: false,
-    fast_forward: nil,
-    disable_child_propagation: false
+    fast_forward_config: nil,
+    disable_propagation: false,
+    max_session_skip_count: 0
   )
   end
 
@@ -1979,70 +2072,85 @@ class Temporalio::Api::Common::V1::TimeSkippingConfig
   def clear_enabled
   end
 
-  # Optionally fast-forward the current workflow execution by this duration ahead of current workflow execution time.
-# After the fast-forward completes, time skipping is disabled, and this
-# action is recorded in the WorkflowExecutionTimeSkippingTransitionedEvent. It can be re-enabled by
-# setting `enabled` to true or setting `fast_forward` again via UpdateWorkflowExecutionOptions.
-# The current workflow execution is a chain of runs (retries, cron, continue-as-new);
-# child workflows are separate executions, so this fast_forward won't affect them.
-#
-# For a given workflow execution, only one active fast-forward is allowed at a time.
-# If a new fast-forward is set via UpdateWorkflowExecutionOptions before the previous
-# one completes, the new one will override the previous one.
-# If the fast-forward duration exceeds the remaining execution timeout, time will only
-# be fast-forwarded up to the end of the execution.
-  sig { returns(T.nilable(Google::Protobuf::Duration)) }
-  def fast_forward
+  # An optional opt-in to control time-skipping behavior through fast-forward; see its definition for details.
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::FastForwardConfig)) }
+  def fast_forward_config
   end
 
-  # Optionally fast-forward the current workflow execution by this duration ahead of current workflow execution time.
-# After the fast-forward completes, time skipping is disabled, and this
-# action is recorded in the WorkflowExecutionTimeSkippingTransitionedEvent. It can be re-enabled by
-# setting `enabled` to true or setting `fast_forward` again via UpdateWorkflowExecutionOptions.
-# The current workflow execution is a chain of runs (retries, cron, continue-as-new);
-# child workflows are separate executions, so this fast_forward won't affect them.
-#
-# For a given workflow execution, only one active fast-forward is allowed at a time.
-# If a new fast-forward is set via UpdateWorkflowExecutionOptions before the previous
-# one completes, the new one will override the previous one.
-# If the fast-forward duration exceeds the remaining execution timeout, time will only
-# be fast-forwarded up to the end of the execution.
-  sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
-  def fast_forward=(value)
+  # An optional opt-in to control time-skipping behavior through fast-forward; see its definition for details.
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::FastForwardConfig)).void }
+  def fast_forward_config=(value)
   end
 
-  # Optionally fast-forward the current workflow execution by this duration ahead of current workflow execution time.
-# After the fast-forward completes, time skipping is disabled, and this
-# action is recorded in the WorkflowExecutionTimeSkippingTransitionedEvent. It can be re-enabled by
-# setting `enabled` to true or setting `fast_forward` again via UpdateWorkflowExecutionOptions.
-# The current workflow execution is a chain of runs (retries, cron, continue-as-new);
-# child workflows are separate executions, so this fast_forward won't affect them.
-#
-# For a given workflow execution, only one active fast-forward is allowed at a time.
-# If a new fast-forward is set via UpdateWorkflowExecutionOptions before the previous
-# one completes, the new one will override the previous one.
-# If the fast-forward duration exceeds the remaining execution timeout, time will only
-# be fast-forwarded up to the end of the execution.
+  # An optional opt-in to control time-skipping behavior through fast-forward; see its definition for details.
   sig { void }
-  def clear_fast_forward
+  def clear_fast_forward_config
   end
 
-  # By default, child workflows inherit the "enabled" flag when they are started.
+  # By default, executions started by another execution (e.g. a child workflow of a parent workflow or
+# a schedule with the time-skipping policy enabled) inherit the "enabled" flag and skip time when possible.
 # This flag disables that inheritance.
   sig { returns(T::Boolean) }
-  def disable_child_propagation
+  def disable_propagation
   end
 
-  # By default, child workflows inherit the "enabled" flag when they are started.
+  # By default, executions started by another execution (e.g. a child workflow of a parent workflow or
+# a schedule with the time-skipping policy enabled) inherit the "enabled" flag and skip time when possible.
 # This flag disables that inheritance.
   sig { params(value: T::Boolean).void }
-  def disable_child_propagation=(value)
+  def disable_propagation=(value)
   end
 
-  # By default, child workflows inherit the "enabled" flag when they are started.
+  # By default, executions started by another execution (e.g. a child workflow of a parent workflow or
+# a schedule with the time-skipping policy enabled) inherit the "enabled" flag and skip time when possible.
 # This flag disables that inheritance.
   sig { void }
-  def clear_disable_child_propagation
+  def clear_disable_propagation
+  end
+
+  # The maximum number of skips allowed every time this field is updated. It protects the execution from
+# situations like unlimited retries when backoff is skipped.
+#
+# Every time the execution skips time, the skip count is incremented by one, and when it reaches
+# max_session_skip_count, time skipping stops. Whenever this config field is updated, the accumulated
+# skip count is cleared, marking the start of a new session.
+# For an execution with a chain of runs (retry, cron, continue-as-new), the count is accumulated
+# across all runs within the same session.
+#
+# If this field is not set, the server applies a large default value (e.g. 100). The default can
+# be changed through dynamic config, and is overridden by this field when set.
+  sig { returns(Integer) }
+  def max_session_skip_count
+  end
+
+  # The maximum number of skips allowed every time this field is updated. It protects the execution from
+# situations like unlimited retries when backoff is skipped.
+#
+# Every time the execution skips time, the skip count is incremented by one, and when it reaches
+# max_session_skip_count, time skipping stops. Whenever this config field is updated, the accumulated
+# skip count is cleared, marking the start of a new session.
+# For an execution with a chain of runs (retry, cron, continue-as-new), the count is accumulated
+# across all runs within the same session.
+#
+# If this field is not set, the server applies a large default value (e.g. 100). The default can
+# be changed through dynamic config, and is overridden by this field when set.
+  sig { params(value: Integer).void }
+  def max_session_skip_count=(value)
+  end
+
+  # The maximum number of skips allowed every time this field is updated. It protects the execution from
+# situations like unlimited retries when backoff is skipped.
+#
+# Every time the execution skips time, the skip count is incremented by one, and when it reaches
+# max_session_skip_count, time skipping stops. Whenever this config field is updated, the accumulated
+# skip count is cleared, marking the start of a new session.
+# For an execution with a chain of runs (retry, cron, continue-as-new), the count is accumulated
+# across all runs within the same session.
+#
+# If this field is not set, the server applies a large default value (e.g. 100). The default can
+# be changed through dynamic config, and is overridden by this field when set.
+  sig { void }
+  def clear_max_session_skip_count
   end
 
   sig { params(field: String).returns(T.untyped) }
@@ -2078,8 +2186,117 @@ class Temporalio::Api::Common::V1::TimeSkippingConfig
   end
 end
 
-# The time-skipping state that needs to be propagated from a parent workflow to a child workflow,
-# or through a chain of runs.
+class Temporalio::Api::Common::V1::FastForwardConfig
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      id: T.nilable(String),
+      duration: T.nilable(Google::Protobuf::Duration)
+    ).void
+  end
+  def initialize(
+    id: "",
+    duration: nil
+  )
+  end
+
+  # A client-supplied ID, required field, set alongside `duration`. It is used to poll for
+# fast-forward completion via PollWorkflowExecutionTimeSkipping.
+# The server performs no idempotency check on this ID; the client is responsible for managing it.
+  sig { returns(String) }
+  def id
+  end
+
+  # A client-supplied ID, required field, set alongside `duration`. It is used to poll for
+# fast-forward completion via PollWorkflowExecutionTimeSkipping.
+# The server performs no idempotency check on this ID; the client is responsible for managing it.
+  sig { params(value: String).void }
+  def id=(value)
+  end
+
+  # A client-supplied ID, required field, set alongside `duration`. It is used to poll for
+# fast-forward completion via PollWorkflowExecutionTimeSkipping.
+# The server performs no idempotency check on this ID; the client is responsible for managing it.
+  sig { void }
+  def clear_id
+  end
+
+  # Fast-forward the current execution by this duration ahead of the current execution time; required field.
+# The duration yields a target time (current execution time + duration), surfaced as `target_time` in
+# TimeSkippingFastForwardInfo. Once virtual time reaches that target, the fast-forward completes, time
+# skipping is disabled, and no further time is skipped. Time skipping can be resumed either
+# by updating the TimeSkippingConfig with a new FastForwardConfig, or by clearing the FastForwardConfig
+# to skip through to the end of the execution.
+#
+# If this duration exceeds the remaining execution timeout, time will not pass beyond the end
+# of the execution, and the fast-forward won't have a chance to complete.
+  sig { returns(T.nilable(Google::Protobuf::Duration)) }
+  def duration
+  end
+
+  # Fast-forward the current execution by this duration ahead of the current execution time; required field.
+# The duration yields a target time (current execution time + duration), surfaced as `target_time` in
+# TimeSkippingFastForwardInfo. Once virtual time reaches that target, the fast-forward completes, time
+# skipping is disabled, and no further time is skipped. Time skipping can be resumed either
+# by updating the TimeSkippingConfig with a new FastForwardConfig, or by clearing the FastForwardConfig
+# to skip through to the end of the execution.
+#
+# If this duration exceeds the remaining execution timeout, time will not pass beyond the end
+# of the execution, and the fast-forward won't have a chance to complete.
+  sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
+  def duration=(value)
+  end
+
+  # Fast-forward the current execution by this duration ahead of the current execution time; required field.
+# The duration yields a target time (current execution time + duration), surfaced as `target_time` in
+# TimeSkippingFastForwardInfo. Once virtual time reaches that target, the fast-forward completes, time
+# skipping is disabled, and no further time is skipped. Time skipping can be resumed either
+# by updating the TimeSkippingConfig with a new FastForwardConfig, or by clearing the FastForwardConfig
+# to skip through to the end of the execution.
+#
+# If this duration exceeds the remaining execution timeout, time will not pass beyond the end
+# of the execution, and the fast-forward won't have a chance to complete.
+  sig { void }
+  def clear_duration
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Temporalio::Api::Common::V1::FastForwardConfig) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::FastForwardConfig).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::FastForwardConfig) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::FastForwardConfig, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# The time-skipping state that needs to be propagated from one execution to another, or through a chain of runs
+# within the same execution.
 class Temporalio::Api::Common::V1::TimeSkippingStatePropagation
   include ::Google::Protobuf::MessageExts
   extend ::Google::Protobuf::MessageExts::ClassMethods
@@ -2087,51 +2304,65 @@ class Temporalio::Api::Common::V1::TimeSkippingStatePropagation
   sig do
     params(
       initial_skipped_duration: T.nilable(Google::Protobuf::Duration),
-      fast_forward_target_time: T.nilable(Google::Protobuf::Timestamp)
+      fast_forward_target_time: T.nilable(Google::Protobuf::Timestamp),
+      initial_skip_count: T.nilable(Integer)
     ).void
   end
   def initialize(
     initial_skipped_duration: nil,
-    fast_forward_target_time: nil
+    fast_forward_target_time: nil,
+    initial_skip_count: 0
   )
   end
 
-  # The time skipped by the previous execution that started this workflow.
-# It can happen in child workflows and a chain of runs (CaN, cron, retry).
+  # The time skipped by the previous run. It is propagated both to executions started by the
+# current execution and through a chain of runs (CaN, cron, retry).
   sig { returns(T.nilable(Google::Protobuf::Duration)) }
   def initial_skipped_duration
   end
 
-  # The time skipped by the previous execution that started this workflow.
-# It can happen in child workflows and a chain of runs (CaN, cron, retry).
+  # The time skipped by the previous run. It is propagated both to executions started by the
+# current execution and through a chain of runs (CaN, cron, retry).
   sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
   def initial_skipped_duration=(value)
   end
 
-  # The time skipped by the previous execution that started this workflow.
-# It can happen in child workflows and a chain of runs (CaN, cron, retry).
+  # The time skipped by the previous run. It is propagated both to executions started by the
+# current execution and through a chain of runs (CaN, cron, retry).
   sig { void }
   def clear_initial_skipped_duration
   end
 
-  # If there is a fast-forward action set for the previous run in a chain of runs,
-# the target time should be propagated to the next run as well.
+  # The fast-forward target time. It only propagates across a chain of runs within the same execution.
   sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
   def fast_forward_target_time
   end
 
-  # If there is a fast-forward action set for the previous run in a chain of runs,
-# the target time should be propagated to the next run as well.
+  # The fast-forward target time. It only propagates across a chain of runs within the same execution.
   sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
   def fast_forward_target_time=(value)
   end
 
-  # If there is a fast-forward action set for the previous run in a chain of runs,
-# the target time should be propagated to the next run as well.
+  # The fast-forward target time. It only propagates across a chain of runs within the same execution.
   sig { void }
   def clear_fast_forward_target_time
   end
 
+  # The initial skip count. It only propagates across a chain of runs within the same execution.
+  sig { returns(Integer) }
+  def initial_skip_count
+  end
+
+  # The initial skip count. It only propagates across a chain of runs within the same execution.
+  sig { params(value: Integer).void }
+  def initial_skip_count=(value)
+  end
+
+  # The initial skip count. It only propagates across a chain of runs within the same execution.
+  sig { void }
+  def clear_initial_skip_count
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end
@@ -2165,6 +2396,249 @@ class Temporalio::Api::Common::V1::TimeSkippingStatePropagation
   end
 end
 
+# Describes the current time-skipping state of a workflow execution.
+class Temporalio::Api::Common::V1::TimeSkippingInfo
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      current_time: T.nilable(Google::Protobuf::Timestamp),
+      effective_config: T.nilable(Temporalio::Api::Common::V1::TimeSkippingConfig),
+      fast_forward_info: T.nilable(Temporalio::Api::Common::V1::TimeSkippingFastForwardInfo),
+      current_session_skip_count: T.nilable(Integer)
+    ).void
+  end
+  def initialize(
+    current_time: nil,
+    effective_config: nil,
+    fast_forward_info: nil,
+    current_session_skip_count: 0
+  )
+  end
+
+  # Current virtual time of the execution. If the execution hasn't skipped
+# any time yet, it will be the same as wall clock time.
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def current_time
+  end
+
+  # Current virtual time of the execution. If the execution hasn't skipped
+# any time yet, it will be the same as wall clock time.
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def current_time=(value)
+  end
+
+  # Current virtual time of the execution. If the execution hasn't skipped
+# any time yet, it will be the same as wall clock time.
+  sig { void }
+  def clear_current_time
+  end
+
+  # The current effective time-skipping config, which can differ from the config the user last set:
+# internally-defaulted fields are populated, and `enabled` reflects whether the execution is still
+# skipping time — e.g. it is set to false once `max_session_skip_count` is reached, the fast-forward
+# completes, or a client call disables time skipping.
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::TimeSkippingConfig)) }
+  def effective_config
+  end
+
+  # The current effective time-skipping config, which can differ from the config the user last set:
+# internally-defaulted fields are populated, and `enabled` reflects whether the execution is still
+# skipping time — e.g. it is set to false once `max_session_skip_count` is reached, the fast-forward
+# completes, or a client call disables time skipping.
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::TimeSkippingConfig)).void }
+  def effective_config=(value)
+  end
+
+  # The current effective time-skipping config, which can differ from the config the user last set:
+# internally-defaulted fields are populated, and `enabled` reflects whether the execution is still
+# skipping time — e.g. it is set to false once `max_session_skip_count` is reached, the fast-forward
+# completes, or a client call disables time skipping.
+  sig { void }
+  def clear_effective_config
+  end
+
+  # The execution's current fast-forward, if any. Unset if time skipping is enabled without a fast-forward.
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::TimeSkippingFastForwardInfo)) }
+  def fast_forward_info
+  end
+
+  # The execution's current fast-forward, if any. Unset if time skipping is enabled without a fast-forward.
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::TimeSkippingFastForwardInfo)).void }
+  def fast_forward_info=(value)
+  end
+
+  # The execution's current fast-forward, if any. Unset if time skipping is enabled without a fast-forward.
+  sig { void }
+  def clear_fast_forward_info
+  end
+
+  # The number of skips accumulated in the current session, bounded by `max_session_skip_count`.
+# A new session begins — and this resets to 0 — each time `max_session_skip_count` is updated.
+  sig { returns(Integer) }
+  def current_session_skip_count
+  end
+
+  # The number of skips accumulated in the current session, bounded by `max_session_skip_count`.
+# A new session begins — and this resets to 0 — each time `max_session_skip_count` is updated.
+  sig { params(value: Integer).void }
+  def current_session_skip_count=(value)
+  end
+
+  # The number of skips accumulated in the current session, bounded by `max_session_skip_count`.
+# A new session begins — and this resets to 0 — each time `max_session_skip_count` is updated.
+  sig { void }
+  def clear_current_session_skip_count
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Temporalio::Api::Common::V1::TimeSkippingInfo) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::TimeSkippingInfo).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::TimeSkippingInfo) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::TimeSkippingInfo, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# TimeSkippingFastForwardInfo describes the current time-skipping fast-forward on an execution.
+class Temporalio::Api::Common::V1::TimeSkippingFastForwardInfo
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      fast_forward_duration: T.nilable(Google::Protobuf::Duration),
+      fast_forward_id: T.nilable(String),
+      target_time: T.nilable(Google::Protobuf::Timestamp),
+      has_completed: T.nilable(T::Boolean)
+    ).void
+  end
+  def initialize(
+    fast_forward_duration: nil,
+    fast_forward_id: "",
+    target_time: nil,
+    has_completed: false
+  )
+  end
+
+  # The client-supplied `fast_forward` duration.
+  sig { returns(T.nilable(Google::Protobuf::Duration)) }
+  def fast_forward_duration
+  end
+
+  # The client-supplied `fast_forward` duration.
+  sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
+  def fast_forward_duration=(value)
+  end
+
+  # The client-supplied `fast_forward` duration.
+  sig { void }
+  def clear_fast_forward_duration
+  end
+
+  # The client-supplied ID set alongside `fast_forward` duration.
+  sig { returns(String) }
+  def fast_forward_id
+  end
+
+  # The client-supplied ID set alongside `fast_forward` duration.
+  sig { params(value: String).void }
+  def fast_forward_id=(value)
+  end
+
+  # The client-supplied ID set alongside `fast_forward` duration.
+  sig { void }
+  def clear_fast_forward_id
+  end
+
+  # The target virtual time at which the fast-forward completes.
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def target_time
+  end
+
+  # The target virtual time at which the fast-forward completes.
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def target_time=(value)
+  end
+
+  # The target virtual time at which the fast-forward completes.
+  sig { void }
+  def clear_target_time
+  end
+
+  # True once `target_time` has been reached.
+  sig { returns(T::Boolean) }
+  def has_completed
+  end
+
+  # True once `target_time` has been reached.
+  sig { params(value: T::Boolean).void }
+  def has_completed=(value)
+  end
+
+  # True once `target_time` has been reached.
+  sig { void }
+  def clear_has_completed
+  end
+
+  sig { params(field: String).returns(T.untyped) }
+  def [](field)
+  end
+
+  sig { params(field: String, value: T.untyped).void }
+  def []=(field, value)
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_h
+  end
+
+  sig { params(str: String).returns(Temporalio::Api::Common::V1::TimeSkippingFastForwardInfo) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::TimeSkippingFastForwardInfo).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::TimeSkippingFastForwardInfo) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::TimeSkippingFastForwardInfo, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
 # Describes an externally stored object referenced by this payload.
 class Temporalio::Api::Common::V1::Payload::ExternalPayloadDetails
   include ::Google::Protobuf::MessageExts