temporalio 1.10.0-aarch64-linux → 1.11.0-aarch64-linux

data/lib/temporalio/workflow/nexus_client.rb

@@ -37,6 +37,9 @@ module Temporalio
       # @param cancellation [Cancellation] Cancellation for the operation.
       # @param arg_hint [Object, nil] Converter hint for the argument.
       # @param result_hint [Object, nil] Converter hint for the result.
+      # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the schedule command, in
+      #   addition to any groups from enclosing {Workflow.with_event_groups} scopes.
+      #   WARNING: This option is experimental.
       # @return [NexusOperationHandle] Handle to the started operation.
       def start_operation(
         operation,
@@ -48,7 +51,8 @@ module Temporalio
         summary: nil,
         cancellation: Workflow.cancellation,
         arg_hint: nil,
-        result_hint: nil
+        result_hint: nil,
+        event_groups: nil
       )
         raise NotImplementedError
       end
@@ -69,6 +73,9 @@ module Temporalio
       # @param cancellation [Cancellation] Cancellation for the operation.
       # @param arg_hint [Object, nil] Converter hint for the argument.
       # @param result_hint [Object, nil] Converter hint for the result.
+      # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the schedule command, in
+      #   addition to any groups from enclosing {Workflow.with_event_groups} scopes.
+      #   WARNING: This option is experimental.
       # @return [Object] Result of the operation.
       # @raise [Error::NexusOperationError] Operation failed.
       def execute_operation(
@@ -81,11 +88,12 @@ module Temporalio
         summary: nil,
         cancellation: Workflow.cancellation,
         arg_hint: nil,
-        result_hint: nil
+        result_hint: nil,
+        event_groups: nil
       )
         start_operation(
           operation, arg, schedule_to_close_timeout:, schedule_to_start_timeout:, start_to_close_timeout:,
-                          cancellation_type:, summary:, cancellation:, arg_hint:, result_hint:
+                          cancellation_type:, summary:, cancellation:, arg_hint:, result_hint:, event_groups:
         ).result
       end
     end

data/lib/temporalio/workflow.rb

@@ -9,6 +9,7 @@ require 'temporalio/workflow/activity_cancellation_type'
 require 'temporalio/workflow/child_workflow_cancellation_type'
 require 'temporalio/workflow/child_workflow_handle'
 require 'temporalio/workflow/definition'
+require 'temporalio/workflow/event_group'
 require 'temporalio/workflow/external_workflow_handle'
 require 'temporalio/workflow/future'
 require 'temporalio/workflow/handler_unfinished_policy'
@@ -55,6 +56,43 @@ module Temporalio
       _current.create_nexus_client(endpoint:, service:)
     end
 
+    # Create an Event Group that can be attached to commands scheduled by this workflow.
+    #
+    # Attach the returned group via command `event_groups:` options, or via {with_event_groups}.
+    #
+    # WARNING: Event Groups support is experimental.
+    #
+    # @param id [String] Non-empty group identity. Commands with the same `id` belong to the same group. The
+    #   user-provided ID is stored as plain text in the workflow history and should therefore not contain sensitive
+    #   information.
+    # @param label [String, nil] Optional non-empty display text for the UI / CLI. If provided, it is persisted to
+    #   history as a codec-encoded Payload.
+    # @return [EventGroup] Created Event Group.
+    def self.create_event_group(id, label: nil)
+      _current
+      raise ArgumentError, 'Event group id cannot be empty' if !id.is_a?(String) || id.empty?
+      raise ArgumentError, 'Event group label cannot be empty' if !label.nil? && (!label.is_a?(String) || label.empty?)
+
+      EventGroup::Label.new(id, label)
+    end
+
+    # Run the given block with one or more Event Groups attached to every command produced inside it.
+    #
+    # Nested scopes compose: a command produced inside an inner scope carries the Event Groups of all enclosing scopes.
+    # Fibers started within a scope inherit it, since they capture Fiber storage at creation.
+    #
+    # WARNING: Event Groups support is experimental.
+    #
+    # @param groups [Array<EventGroup>] Event Groups created via {create_event_group}.
+    # @yield Block to run with the given Event Groups in scope.
+    # @return [Object] Result of the block.
+    def self.with_event_groups(*groups, &)
+      raise ArgumentError, 'Block required' unless block_given?
+
+      _current
+      EventGroup._with_event_groups(*groups, &)
+    end
+
     # @return [Array<SuggestContinueAsNewReason::enum>] Reasons the server suggests continue-as-new. Empty if no
     #   suggestion. This is currently experimental.
     def self.suggest_continue_as_new_reasons
@@ -122,8 +160,10 @@ module Temporalio
     # removed as well.
     #
     # @param patch_id [Symbol, String] Patch ID.
-    def self.deprecate_patch(patch_id)
-      _current.deprecate_patch(patch_id)
+    # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the patch marker command.
+    #   WARNING: This option is experimental.
+    def self.deprecate_patch(patch_id, event_groups: nil)
+      _current.deprecate_patch(patch_id, event_groups:)
     end
 
     # Execute an activity and return its result. Either `start_to_close_timeout` or `schedule_to_close_timeout` _must_
@@ -164,6 +204,9 @@ module Temporalio
     #   activity definition has arg hints, those are used by default.
     # @param result_hint [Object, nil] Overrides converter hint for result if any. If unset/nil and the activity
     #   definition has result hint, it is used by default.
+    # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the activity command, in
+    #   addition to any groups from enclosing {with_event_groups} scopes.
+    #   WARNING: This option is experimental.
     #
     # @return [Object] Result of the activity.
     # @raise [Error::ActivityError] Activity failed (and retry was disabled or exhausted).
@@ -185,13 +228,14 @@ module Temporalio
       disable_eager_execution: false,
       priority: Priority.default,
       arg_hints: nil,
-      result_hint: nil
+      result_hint: nil,
+      event_groups: nil
     )
       _current.execute_activity(
         activity, *args,
         task_queue:, summary:, schedule_to_close_timeout:, schedule_to_start_timeout:, start_to_close_timeout:,
         heartbeat_timeout:, retry_policy:, cancellation:, cancellation_type:, activity_id:, disable_eager_execution:,
-        priority:, arg_hints:, result_hint:
+        priority:, arg_hints:, result_hint:, event_groups:
       )
     end
 
@@ -217,14 +261,15 @@ module Temporalio
       priority: Priority.default,
       versioning_override: nil,
       arg_hints: nil,
-      result_hint: nil
+      result_hint: nil,
+      event_groups: nil
     )
       start_child_workflow(
         workflow, *args,
         id:, task_queue:, static_summary:, static_details:, cancellation:, cancellation_type:,
         parent_close_policy:, execution_timeout:, run_timeout:, task_timeout:, id_reuse_policy:,
         retry_policy:, cron_schedule:, memo:, search_attributes:, priority:, versioning_override:,
-        arg_hints:, result_hint:
+        arg_hints:, result_hint:, event_groups:
       ).result
     end
 
@@ -261,6 +306,9 @@ module Temporalio
     #   activity definition has arg hints, those are used by default.
     # @param result_hint [Object, nil] Overrides converter hint for result if any. If unset/nil and the activity
     #   definition has result hint, it is used by default.
+    # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the activity command, in
+    #   addition to any groups from enclosing {with_event_groups} scopes.
+    #   WARNING: This option is experimental.
     #
     # @return [Object] Result of the activity.
     # @raise [Error::ActivityError] Activity failed (and retry was disabled or exhausted).
@@ -279,13 +327,14 @@ module Temporalio
       cancellation_type: ActivityCancellationType::TRY_CANCEL,
       activity_id: nil,
       arg_hints: nil,
-      result_hint: nil
+      result_hint: nil,
+      event_groups: nil
     )
       _current.execute_local_activity(
         activity, *args,
         summary:, schedule_to_close_timeout:, schedule_to_start_timeout:, start_to_close_timeout:,
         retry_policy:, local_retry_threshold:, cancellation:, cancellation_type:,
-        activity_id:, arg_hints:, result_hint:
+        activity_id:, arg_hints:, result_hint:, event_groups:
       )
     end
 
@@ -351,9 +400,11 @@ module Temporalio
     # deployments. That callback is only used when the patch marker would otherwise be created for the first time.
     #
     # @param patch_id [Symbol, String] Patch ID.
+    # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the patch marker command.
+    #   WARNING: This option is experimental.
     # @return [Boolean] True if this should take the newer patch, false if it should take the old path.
-    def self.patched(patch_id)
-      _current.patched(patch_id)
+    def self.patched(patch_id, event_groups: nil)
+      _current.patched(patch_id, event_groups:)
     end
 
     # @return [Converters::PayloadConverter] Payload converter for the workflow.
@@ -398,9 +449,12 @@ module Temporalio
     # @param summary [String, nil] A simple string identifying this timer that may be visible in UI/CLI. While it can be
     #   normal text, it is best to treat as a timer ID.
     # @param cancellation [Cancellation] Cancellation for this timer.
+    # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the timer command, in addition
+    #   to any groups from enclosing {with_event_groups} scopes.
+    #   WARNING: This option is experimental.
     # @raise [Error::CanceledError] Sleep canceled.
-    def self.sleep(duration, summary: nil, cancellation: Workflow.cancellation)
-      _current.sleep(duration, summary:, cancellation:)
+    def self.sleep(duration, summary: nil, cancellation: Workflow.cancellation, event_groups: nil)
+      _current.sleep(duration, summary:, cancellation:, event_groups:)
     end
 
     # Start a child workflow and return the handle.
@@ -435,6 +489,9 @@ module Temporalio
     #   workflow definition has arg hints, those are used by default.
     # @param result_hint [Object, nil] Overrides converter hint for result if any. If unset/nil and the workflow
     #   definition has result hint, it is used by default.
+    # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the start-child command, in
+    #   addition to any groups from enclosing {with_event_groups} scopes.
+    #   WARNING: This option is experimental.
     #
     # @return [ChildWorkflowHandle] Workflow handle to the started workflow.
     # @raise [Error::WorkflowAlreadyStartedError] Workflow already exists for the ID.
@@ -462,14 +519,15 @@ module Temporalio
       priority: Priority.default,
       versioning_override: nil,
       arg_hints: nil,
-      result_hint: nil
+      result_hint: nil,
+      event_groups: nil
     )
       _current.start_child_workflow(
         workflow, *args,
         id:, task_queue:, static_summary:, static_details:, cancellation:, cancellation_type:,
         parent_close_policy:, execution_timeout:, run_timeout:, task_timeout:, id_reuse_policy:,
         retry_policy:, cron_schedule:, memo:, search_attributes:, priority:, versioning_override:,
-        arg_hints:, result_hint:
+        arg_hints:, result_hint:, event_groups:
       )
     end
 
@@ -490,6 +548,10 @@ module Temporalio
     #   {::Timeout.timeout}.
     # @param summary [String] Timer summary for the timer created by this timeout. This is backed by {sleep} so see that
     #   method for details.
+    # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the timeout timer, in addition
+    #   to any groups from enclosing {with_event_groups} scopes. Prefer this over {wait_condition} for
+    #   wait-with-timeout.
+    #   WARNING: This option is experimental.
     #
     # @yield Block to run with a timeout.
     # @return [Object] The result of the block.
@@ -499,9 +561,10 @@ module Temporalio
       exception_class = Timeout::Error,
       message = 'execution expired',
       summary: 'Timeout timer',
+      event_groups: nil,
       &
     )
-      _current.timeout(duration, exception_class, message, summary:, &)
+      _current.timeout(duration, exception_class, message, summary:, event_groups:, &)
     end
 
     # @return [Hash<String, Definition::Update>] Update handlers for this workflow. This hash is mostly immutable except
@@ -513,18 +576,37 @@ module Temporalio
 
     # Issue updates to the workflow memo.
     #
-    # @param hash [Hash{String, Symbol => Object, nil}] Updates to apply. Value can be `nil` to effectively remove the
-    #   memo value.
-    def self.upsert_memo(hash)
-      _current.upsert_memo(hash)
+    # @overload upsert_memo(hash, event_groups: nil)
+    #   @param hash [Hash{String, Symbol => Object, nil}] Updates to apply. Value can be `nil` to effectively remove the
+    #     memo value.
+    #   @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the modify-properties command.
+    #     WARNING: This option is experimental.
+    # @overload upsert_memo(event_groups: nil, **memo)
+    #   @param memo [Hash{String, Symbol => Object, nil}] Updates to apply. Value can be `nil` to effectively remove the
+    #     memo value.
+    #   @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the modify-properties command.
+    #     WARNING: This option is experimental.
+    def self.upsert_memo(hash = nil, event_groups: nil, **memo)
+      if hash
+        unless memo.empty?
+          raise ArgumentError, 'Memo updates must be passed either as a hash or as keyword arguments, not both'
+        end
+      else
+        hash = memo
+      end
+
+      _current.upsert_memo(hash, event_groups:)
     end
 
     # Issue updates to the workflow search attributes.
     #
     # @param updates [Array<SearchAttributes::Update>] Updates to apply. Note these are {SearchAttributes::Update}
     #   objects which are created via {SearchAttributes::Key.value_set} and {SearchAttributes::Key.value_unset} methods.
-    def self.upsert_search_attributes(*updates)
-      _current.upsert_search_attributes(*updates)
+    # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the upsert-search-attributes
+    #   command.
+    #   WARNING: This option is experimental.
+    def self.upsert_search_attributes(*updates, event_groups: nil)
+      _current.upsert_search_attributes(*updates, event_groups:)
     end
 
     # Wait for the given block to return a "truthy" value (i.e. any value other than `false` or `nil`). The block must
@@ -661,6 +743,7 @@ module Temporalio
                     :backoff_start_interval,
                     :retry_policy, :memo, :search_attributes, :arg_hints, :headers,
                     :initial_versioning_behavior
+      attr_reader :event_groups
 
       # Create a continue as new error.
       #
@@ -689,6 +772,8 @@ module Temporalio
       #   first task of the new run. Set to {ContinueAsNewVersioningBehavior::AUTO_UPGRADE} to upgrade a pinned workflow
       #   to the latest version on continue-as-new or {ContinueAsNewVersioningBehavior::USE_RAMPING_VERSION} to start on
       #   the task queue's Ramping Version. This is currently experimental.
+      # @param event_groups [Array<EventGroup>, nil] Event Groups to attach to the continue-as-new command.
+      #   WARNING: This option is experimental.
       def initialize(
         *args,
         workflow: nil,
@@ -701,7 +786,8 @@ module Temporalio
         search_attributes: nil,
         arg_hints: nil,
         headers: {},
-        initial_versioning_behavior: nil
+        initial_versioning_behavior: nil,
+        event_groups: nil
       )
         super('Continue as new')
         @args = args
@@ -716,8 +802,14 @@ module Temporalio
         @arg_hints = arg_hints
         @headers = headers
         @initial_versioning_behavior = initial_versioning_behavior
+        @event_groups = event_groups
         Workflow._current.initialize_continue_as_new_error(self)
       end
+
+      # @!visibility private
+      private
+
+      attr_accessor :_event_group_markers
     end
 
     # Error raised when a workflow does something with a side effect in an improper context. In `initialize`, query

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

@@ -384,7 +384,10 @@ class Temporalio::Api::Activity::V1::ActivityExecutionInfo
       start_delay: T.nilable(Google::Protobuf::Duration),
       execution_time: T.nilable(Google::Protobuf::Timestamp),
       propagated_nexus_serialization_context: T.nilable(Temporalio::Api::Nexus::V1::PropagatedSerializationContext),
-      eager_execution_accepted: T.nilable(T::Boolean)
+      eager_execution_accepted: T.nilable(T::Boolean),
+      started_by_principal: T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal),
+      closed_by_principal: T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal),
+      last_worker_principal: T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal)
     ).void
   end
   def initialize(
@@ -427,7 +430,10 @@ class Temporalio::Api::Activity::V1::ActivityExecutionInfo
     start_delay: nil,
     execution_time: nil,
     propagated_nexus_serialization_context: nil,
-    eager_execution_accepted: false
+    eager_execution_accepted: false,
+    started_by_principal: nil,
+    closed_by_principal: nil,
+    last_worker_principal: nil
   )
   end
 
@@ -1097,6 +1103,69 @@ class Temporalio::Api::Activity::V1::ActivityExecutionInfo
   def clear_eager_execution_accepted
   end
 
+  # Authenticated principal by which this activity execution was started.
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "by" identifies the authenticated actor. --)
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal)) }
+  def started_by_principal
+  end
+
+  # Authenticated principal by which this activity execution was started.
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "by" identifies the authenticated actor. --)
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal)).void }
+  def started_by_principal=(value)
+  end
+
+  # Authenticated principal by which this activity execution was started.
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "by" identifies the authenticated actor. --)
+  sig { void }
+  def clear_started_by_principal
+  end
+
+  # Authenticated principal by which this activity execution was closed.
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "by" identifies the authenticated actor. --)
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal)) }
+  def closed_by_principal
+  end
+
+  # Authenticated principal by which this activity execution was closed.
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "by" identifies the authenticated actor. --)
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal)).void }
+  def closed_by_principal=(value)
+  end
+
+  # Authenticated principal by which this activity execution was closed.
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "by" identifies the authenticated actor. --)
+  sig { void }
+  def clear_closed_by_principal
+  end
+
+  # Authenticated principal of the worker that most recently interacted with this activity execution.
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal)) }
+  def last_worker_principal
+  end
+
+  # Authenticated principal of the worker that most recently interacted with this activity execution.
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::ResolvedPrincipal)).void }
+  def last_worker_principal=(value)
+  end
+
+  # Authenticated principal of the worker that most recently interacted with this activity execution.
+  sig { void }
+  def clear_last_worker_principal
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end

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

@@ -1634,6 +1634,101 @@ class Temporalio::Api::Common::V1::Principal
   end
 end
 
+# ResolvedPrincipal is a principal returned to an API caller.
+class Temporalio::Api::Common::V1::ResolvedPrincipal
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      type: T.nilable(String),
+      name_at_write_time: T.nilable(String)
+    ).void
+  end
+  def initialize(
+    type: "",
+    name_at_write_time: ""
+  )
+  end
+
+  # Low-cardinality category of the principal (e.g., "jwt", "users").
+  sig { returns(String) }
+  def type
+  end
+
+  # Low-cardinality category of the principal (e.g., "jwt", "users").
+  sig { params(value: String).void }
+  def type=(value)
+  end
+
+  # Low-cardinality category of the principal (e.g., "jwt", "users").
+  sig { void }
+  def clear_type
+  end
+
+  # Identifier within that category (e.g., sub JWT claim, email address).
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: Identifies the principal name snapshot used for this response. --)
+# (-- api-linter: core::0142::time-field-type=disabled
+#     aip.dev/not-precedent: This string is a principal name snapshot, not a timestamp. --)
+  sig { returns(String) }
+  def name_at_write_time
+  end
+
+  # Identifier within that category (e.g., sub JWT claim, email address).
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: Identifies the principal name snapshot used for this response. --)
+# (-- api-linter: core::0142::time-field-type=disabled
+#     aip.dev/not-precedent: This string is a principal name snapshot, not a timestamp. --)
+  sig { params(value: String).void }
+  def name_at_write_time=(value)
+  end
+
+  # Identifier within that category (e.g., sub JWT claim, email address).
+#
+# (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: Identifies the principal name snapshot used for this response. --)
+# (-- api-linter: core::0142::time-field-type=disabled
+#     aip.dev/not-precedent: This string is a principal name snapshot, not a timestamp. --)
+  sig { void }
+  def clear_name_at_write_time
+  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::ResolvedPrincipal) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::ResolvedPrincipal).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::ResolvedPrincipal) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::Common::V1::ResolvedPrincipal, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
 # Priority contains metadata that controls relative ordering of task processing
 # when tasks are backed up in a queue. Initially, Priority will be used in
 # matching (workflow and activity) task queues. Later it may be used in history

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

@@ -1630,14 +1630,16 @@ class Temporalio::Api::Schedule::V1::SchedulePatch
       trigger_immediately: T.nilable(Temporalio::Api::Schedule::V1::TriggerImmediatelyRequest),
       backfill_request: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::BackfillRequest)]),
       pause: T.nilable(String),
-      unpause: T.nilable(String)
+      unpause: T.nilable(String),
+      time_skipping_config: T.nilable(Temporalio::Api::Common::V1::TimeSkippingConfig)
     ).void
   end
   def initialize(
     trigger_immediately: nil,
     backfill_request: [],
     pause: "",
-    unpause: ""
+    unpause: "",
+    time_skipping_config: nil
   )
   end
 
@@ -1707,6 +1709,24 @@ class Temporalio::Api::Schedule::V1::SchedulePatch
   def clear_unpause
   end
 
+  # If set, applies the specified time-skipping configuration to this schedule,
+# replacing any existing time-skipping configuration.
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::TimeSkippingConfig)) }
+  def time_skipping_config
+  end
+
+  # If set, applies the specified time-skipping configuration to this schedule,
+# replacing any existing time-skipping configuration.
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::TimeSkippingConfig)).void }
+  def time_skipping_config=(value)
+  end
+
+  # If set, applies the specified time-skipping configuration to this schedule,
+# replacing any existing time-skipping configuration.
+  sig { void }
+  def clear_time_skipping_config
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end
@@ -1757,7 +1777,8 @@ class Temporalio::Api::Schedule::V1::ScheduleInfo
       create_time: T.nilable(Google::Protobuf::Timestamp),
       update_time: T.nilable(Google::Protobuf::Timestamp),
       invalid_schedule_error: T.nilable(String),
-      state_size_bytes: T.nilable(Integer)
+      state_size_bytes: T.nilable(Integer),
+      time_skipping_info: T.nilable(Temporalio::Api::Common::V1::TimeSkippingInfo)
     ).void
   end
   def initialize(
@@ -1772,7 +1793,8 @@ class Temporalio::Api::Schedule::V1::ScheduleInfo
     create_time: nil,
     update_time: nil,
     invalid_schedule_error: "",
-    state_size_bytes: 0
+    state_size_bytes: 0,
+    time_skipping_info: nil
   )
   end
 
@@ -1971,6 +1993,24 @@ class Temporalio::Api::Schedule::V1::ScheduleInfo
   def clear_state_size_bytes
   end
 
+  # Information about time skipping for this schedule.
+# If the schedule has never enabled time skipping, this will be unset.
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::TimeSkippingInfo)) }
+  def time_skipping_info
+  end
+
+  # Information about time skipping for this schedule.
+# If the schedule has never enabled time skipping, this will be unset.
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::TimeSkippingInfo)).void }
+  def time_skipping_info=(value)
+  end
+
+  # Information about time skipping for this schedule.
+# If the schedule has never enabled time skipping, this will be unset.
+  sig { void }
+  def clear_time_skipping_info
+  end
+
   sig { params(field: String).returns(T.untyped) }
   def [](field)
   end