temporalio 1.5.0 → 1.6.0

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

@@ -0,0 +1,2460 @@
+# Code generated by protoc-gen-rbi. DO NOT EDIT.
+# source: temporal/api/taskqueue/v1/message.proto
+# typed: strict
+
+# See https://docs.temporal.io/docs/concepts/task-queues/
+class Temporalio::Api::TaskQueue::V1::TaskQueue
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      name: T.nilable(String),
+      kind: T.nilable(T.any(Symbol, String, Integer)),
+      normal_name: T.nilable(String)
+    ).void
+  end
+  def initialize(
+    name: "",
+    kind: :TASK_QUEUE_KIND_UNSPECIFIED,
+    normal_name: ""
+  )
+  end
+
+  sig { returns(String) }
+  def name
+  end
+
+  sig { params(value: String).void }
+  def name=(value)
+  end
+
+  sig { void }
+  def clear_name
+  end
+
+  # Default: TASK_QUEUE_KIND_NORMAL.
+  sig { returns(T.any(Symbol, Integer)) }
+  def kind
+  end
+
+  # Default: TASK_QUEUE_KIND_NORMAL.
+  sig { params(value: T.any(Symbol, String, Integer)).void }
+  def kind=(value)
+  end
+
+  # Default: TASK_QUEUE_KIND_NORMAL.
+  sig { void }
+  def clear_kind
+  end
+
+  # Iff kind == TASK_QUEUE_KIND_STICKY, then this field contains the name of
+# the normal task queue that the sticky worker is running on.
+  sig { returns(String) }
+  def normal_name
+  end
+
+  # Iff kind == TASK_QUEUE_KIND_STICKY, then this field contains the name of
+# the normal task queue that the sticky worker is running on.
+  sig { params(value: String).void }
+  def normal_name=(value)
+  end
+
+  # Iff kind == TASK_QUEUE_KIND_STICKY, then this field contains the name of
+# the normal task queue that the sticky worker is running on.
+  sig { void }
+  def clear_normal_name
+  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::TaskQueue::V1::TaskQueue) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueue).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueue) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueue, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# Only applies to activity task queues
+class Temporalio::Api::TaskQueue::V1::TaskQueueMetadata
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      max_tasks_per_second: T.nilable(Google::Protobuf::DoubleValue)
+    ).void
+  end
+  def initialize(
+    max_tasks_per_second: nil
+  )
+  end
+
+  # Allows throttling dispatch of tasks from this queue
+  sig { returns(T.nilable(Google::Protobuf::DoubleValue)) }
+  def max_tasks_per_second
+  end
+
+  # Allows throttling dispatch of tasks from this queue
+  sig { params(value: T.nilable(Google::Protobuf::DoubleValue)).void }
+  def max_tasks_per_second=(value)
+  end
+
+  # Allows throttling dispatch of tasks from this queue
+  sig { void }
+  def clear_max_tasks_per_second
+  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::TaskQueue::V1::TaskQueueMetadata) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueMetadata).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueMetadata) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueMetadata, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::TaskQueueVersioningInfo
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      current_deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion),
+      current_version: T.nilable(String),
+      ramping_deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion),
+      ramping_version: T.nilable(String),
+      ramping_version_percentage: T.nilable(Float),
+      update_time: T.nilable(Google::Protobuf::Timestamp)
+    ).void
+  end
+  def initialize(
+    current_deployment_version: nil,
+    current_version: "",
+    ramping_deployment_version: nil,
+    ramping_version: "",
+    ramping_version_percentage: 0.0,
+    update_time: nil
+  )
+  end
+
+  # Specifies which Deployment Version should receive new workflow executions and tasks of
+# existing unversioned or AutoUpgrade workflows.
+# Nil value represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.)
+# Note: Current Version is overridden by the Ramping Version for a portion of traffic when ramp percentage
+# is non-zero (see `ramping_deployment_version` and `ramping_version_percentage`).
+  sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) }
+  def current_deployment_version
+  end
+
+  # Specifies which Deployment Version should receive new workflow executions and tasks of
+# existing unversioned or AutoUpgrade workflows.
+# Nil value represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.)
+# Note: Current Version is overridden by the Ramping Version for a portion of traffic when ramp percentage
+# is non-zero (see `ramping_deployment_version` and `ramping_version_percentage`).
+  sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void }
+  def current_deployment_version=(value)
+  end
+
+  # Specifies which Deployment Version should receive new workflow executions and tasks of
+# existing unversioned or AutoUpgrade workflows.
+# Nil value represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.)
+# Note: Current Version is overridden by the Ramping Version for a portion of traffic when ramp percentage
+# is non-zero (see `ramping_deployment_version` and `ramping_version_percentage`).
+  sig { void }
+  def clear_current_deployment_version
+  end
+
+  # Deprecated. Use `current_deployment_version`.
+  sig { returns(String) }
+  def current_version
+  end
+
+  # Deprecated. Use `current_deployment_version`.
+  sig { params(value: String).void }
+  def current_version=(value)
+  end
+
+  # Deprecated. Use `current_deployment_version`.
+  sig { void }
+  def clear_current_version
+  end
+
+  # When ramp percentage is non-zero, that portion of traffic is shifted from the Current Version to the Ramping Version.
+# Must always be different from `current_deployment_version` unless both are nil.
+# Nil value represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.)
+# Note that it is possible to ramp from one Version to another Version, or from unversioned
+# workers to a particular Version, or from a particular Version to unversioned workers.
+  sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) }
+  def ramping_deployment_version
+  end
+
+  # When ramp percentage is non-zero, that portion of traffic is shifted from the Current Version to the Ramping Version.
+# Must always be different from `current_deployment_version` unless both are nil.
+# Nil value represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.)
+# Note that it is possible to ramp from one Version to another Version, or from unversioned
+# workers to a particular Version, or from a particular Version to unversioned workers.
+  sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void }
+  def ramping_deployment_version=(value)
+  end
+
+  # When ramp percentage is non-zero, that portion of traffic is shifted from the Current Version to the Ramping Version.
+# Must always be different from `current_deployment_version` unless both are nil.
+# Nil value represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.)
+# Note that it is possible to ramp from one Version to another Version, or from unversioned
+# workers to a particular Version, or from a particular Version to unversioned workers.
+  sig { void }
+  def clear_ramping_deployment_version
+  end
+
+  # Deprecated. Use `ramping_deployment_version`.
+  sig { returns(String) }
+  def ramping_version
+  end
+
+  # Deprecated. Use `ramping_deployment_version`.
+  sig { params(value: String).void }
+  def ramping_version=(value)
+  end
+
+  # Deprecated. Use `ramping_deployment_version`.
+  sig { void }
+  def clear_ramping_version
+  end
+
+  # Percentage of tasks that are routed to the Ramping Version instead of the Current Version.
+# Valid range: [0, 100]. A 100% value means the Ramping Version is receiving full traffic but
+# not yet "promoted" to be the Current Version, likely due to pending validations.
+# A 0% value means the Ramping Version is receiving no traffic.
+  sig { returns(Float) }
+  def ramping_version_percentage
+  end
+
+  # Percentage of tasks that are routed to the Ramping Version instead of the Current Version.
+# Valid range: [0, 100]. A 100% value means the Ramping Version is receiving full traffic but
+# not yet "promoted" to be the Current Version, likely due to pending validations.
+# A 0% value means the Ramping Version is receiving no traffic.
+  sig { params(value: Float).void }
+  def ramping_version_percentage=(value)
+  end
+
+  # Percentage of tasks that are routed to the Ramping Version instead of the Current Version.
+# Valid range: [0, 100]. A 100% value means the Ramping Version is receiving full traffic but
+# not yet "promoted" to be the Current Version, likely due to pending validations.
+# A 0% value means the Ramping Version is receiving no traffic.
+  sig { void }
+  def clear_ramping_version_percentage
+  end
+
+  # Last time versioning information of this Task Queue changed.
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def update_time
+  end
+
+  # Last time versioning information of this Task Queue changed.
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def update_time=(value)
+  end
+
+  # Last time versioning information of this Task Queue changed.
+  sig { void }
+  def clear_update_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::TaskQueue::V1::TaskQueueVersioningInfo) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueVersioningInfo).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueVersioningInfo) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueVersioningInfo, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# Used for specifying versions the caller is interested in.
+class Temporalio::Api::TaskQueue::V1::TaskQueueVersionSelection
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      build_ids: T.nilable(T::Array[String]),
+      unversioned: T.nilable(T::Boolean),
+      all_active: T.nilable(T::Boolean)
+    ).void
+  end
+  def initialize(
+    build_ids: [],
+    unversioned: false,
+    all_active: false
+  )
+  end
+
+  # Include specific Build IDs.
+  sig { returns(T::Array[String]) }
+  def build_ids
+  end
+
+  # Include specific Build IDs.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def build_ids=(value)
+  end
+
+  # Include specific Build IDs.
+  sig { void }
+  def clear_build_ids
+  end
+
+  # Include the unversioned queue.
+  sig { returns(T::Boolean) }
+  def unversioned
+  end
+
+  # Include the unversioned queue.
+  sig { params(value: T::Boolean).void }
+  def unversioned=(value)
+  end
+
+  # Include the unversioned queue.
+  sig { void }
+  def clear_unversioned
+  end
+
+  # Include all active versions. A version is considered active if, in the last few minutes,
+# it has had new tasks or polls, or it has been the subject of certain task queue API calls.
+  sig { returns(T::Boolean) }
+  def all_active
+  end
+
+  # Include all active versions. A version is considered active if, in the last few minutes,
+# it has had new tasks or polls, or it has been the subject of certain task queue API calls.
+  sig { params(value: T::Boolean).void }
+  def all_active=(value)
+  end
+
+  # Include all active versions. A version is considered active if, in the last few minutes,
+# it has had new tasks or polls, or it has been the subject of certain task queue API calls.
+  sig { void }
+  def clear_all_active
+  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::TaskQueue::V1::TaskQueueVersionSelection) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueVersionSelection).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueVersionSelection) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueVersionSelection, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::TaskQueueVersionInfo
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      types_info: T.nilable(T::Hash[Integer, T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueTypeInfo)]),
+      task_reachability: T.nilable(T.any(Symbol, String, Integer))
+    ).void
+  end
+  def initialize(
+    types_info: ::Google::Protobuf::Map.new(:int32, :message, Temporalio::Api::TaskQueue::V1::TaskQueueTypeInfo),
+    task_reachability: :BUILD_ID_TASK_REACHABILITY_UNSPECIFIED
+  )
+  end
+
+  # Task Queue info per Task Type. Key is the numerical value of the temporal.api.enums.v1.TaskQueueType enum.
+  sig { returns(T::Hash[Integer, T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueTypeInfo)]) }
+  def types_info
+  end
+
+  # Task Queue info per Task Type. Key is the numerical value of the temporal.api.enums.v1.TaskQueueType enum.
+  sig { params(value: ::Google::Protobuf::Map).void }
+  def types_info=(value)
+  end
+
+  # Task Queue info per Task Type. Key is the numerical value of the temporal.api.enums.v1.TaskQueueType enum.
+  sig { void }
+  def clear_types_info
+  end
+
+  # Task Reachability is eventually consistent; there may be a delay until it converges to the most
+# accurate value but it is designed in a way to take the more conservative side until it converges.
+# For example REACHABLE is more conservative than CLOSED_WORKFLOWS_ONLY.
+#
+# Note: future activities who inherit their workflow's Build ID but not its Task Queue will not be
+# accounted for reachability as server cannot know if they'll happen as they do not use
+# assignment rules of their Task Queue. Same goes for Child Workflows or Continue-As-New Workflows
+# who inherit the parent/previous workflow's Build ID but not its Task Queue. In those cases, make
+# sure to query reachability for the parent/previous workflow's Task Queue as well.
+  sig { returns(T.any(Symbol, Integer)) }
+  def task_reachability
+  end
+
+  # Task Reachability is eventually consistent; there may be a delay until it converges to the most
+# accurate value but it is designed in a way to take the more conservative side until it converges.
+# For example REACHABLE is more conservative than CLOSED_WORKFLOWS_ONLY.
+#
+# Note: future activities who inherit their workflow's Build ID but not its Task Queue will not be
+# accounted for reachability as server cannot know if they'll happen as they do not use
+# assignment rules of their Task Queue. Same goes for Child Workflows or Continue-As-New Workflows
+# who inherit the parent/previous workflow's Build ID but not its Task Queue. In those cases, make
+# sure to query reachability for the parent/previous workflow's Task Queue as well.
+  sig { params(value: T.any(Symbol, String, Integer)).void }
+  def task_reachability=(value)
+  end
+
+  # Task Reachability is eventually consistent; there may be a delay until it converges to the most
+# accurate value but it is designed in a way to take the more conservative side until it converges.
+# For example REACHABLE is more conservative than CLOSED_WORKFLOWS_ONLY.
+#
+# Note: future activities who inherit their workflow's Build ID but not its Task Queue will not be
+# accounted for reachability as server cannot know if they'll happen as they do not use
+# assignment rules of their Task Queue. Same goes for Child Workflows or Continue-As-New Workflows
+# who inherit the parent/previous workflow's Build ID but not its Task Queue. In those cases, make
+# sure to query reachability for the parent/previous workflow's Task Queue as well.
+  sig { void }
+  def clear_task_reachability
+  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::TaskQueue::V1::TaskQueueVersionInfo) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueVersionInfo).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueVersionInfo) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueVersionInfo, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::TaskQueueTypeInfo
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      pollers: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerInfo)]),
+      stats: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)
+    ).void
+  end
+  def initialize(
+    pollers: [],
+    stats: nil
+  )
+  end
+
+  # Unversioned workers (with `useVersioning=false`) are reported in unversioned result even if they set a Build ID.
+  sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerInfo)]) }
+  def pollers
+  end
+
+  # Unversioned workers (with `useVersioning=false`) are reported in unversioned result even if they set a Build ID.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def pollers=(value)
+  end
+
+  # Unversioned workers (with `useVersioning=false`) are reported in unversioned result even if they set a Build ID.
+  sig { void }
+  def clear_pollers
+  end
+
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)) }
+  def stats
+  end
+
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)).void }
+  def stats=(value)
+  end
+
+  sig { void }
+  def clear_stats
+  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::TaskQueue::V1::TaskQueueTypeInfo) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueTypeInfo).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueTypeInfo) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueTypeInfo, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# TaskQueueStats contains statistics about task queue backlog and activity.
+#
+# For workflow task queue type, this result is partial because tasks sent to sticky queues are not included. Read
+# comments above each metric to understand the impact of sticky queue exclusion on that metric accuracy.
+class Temporalio::Api::TaskQueue::V1::TaskQueueStats
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      approximate_backlog_count: T.nilable(Integer),
+      approximate_backlog_age: T.nilable(Google::Protobuf::Duration),
+      tasks_add_rate: T.nilable(Float),
+      tasks_dispatch_rate: T.nilable(Float)
+    ).void
+  end
+  def initialize(
+    approximate_backlog_count: 0,
+    approximate_backlog_age: nil,
+    tasks_add_rate: 0.0,
+    tasks_dispatch_rate: 0.0
+  )
+  end
+
+  # The approximate number of tasks backlogged in this task queue. May count expired tasks but eventually
+# converges to the right value. Can be relied upon for scaling decisions.
+#
+# Special note for workflow task queue type: this metric does not count sticky queue tasks. However, because
+# those tasks only remain valid for a few seconds, the inaccuracy becomes less significant as the backlog size
+# grows.
+  sig { returns(Integer) }
+  def approximate_backlog_count
+  end
+
+  # The approximate number of tasks backlogged in this task queue. May count expired tasks but eventually
+# converges to the right value. Can be relied upon for scaling decisions.
+#
+# Special note for workflow task queue type: this metric does not count sticky queue tasks. However, because
+# those tasks only remain valid for a few seconds, the inaccuracy becomes less significant as the backlog size
+# grows.
+  sig { params(value: Integer).void }
+  def approximate_backlog_count=(value)
+  end
+
+  # The approximate number of tasks backlogged in this task queue. May count expired tasks but eventually
+# converges to the right value. Can be relied upon for scaling decisions.
+#
+# Special note for workflow task queue type: this metric does not count sticky queue tasks. However, because
+# those tasks only remain valid for a few seconds, the inaccuracy becomes less significant as the backlog size
+# grows.
+  sig { void }
+  def clear_approximate_backlog_count
+  end
+
+  # Approximate age of the oldest task in the backlog based on the creation time of the task at the head of
+# the queue. Can be relied upon for scaling decisions.
+#
+# Special note for workflow task queue type: this metric does not count sticky queue tasks. However, because
+# those tasks only remain valid for a few seconds, they should not affect the result when backlog is older than
+# few seconds.
+  sig { returns(T.nilable(Google::Protobuf::Duration)) }
+  def approximate_backlog_age
+  end
+
+  # Approximate age of the oldest task in the backlog based on the creation time of the task at the head of
+# the queue. Can be relied upon for scaling decisions.
+#
+# Special note for workflow task queue type: this metric does not count sticky queue tasks. However, because
+# those tasks only remain valid for a few seconds, they should not affect the result when backlog is older than
+# few seconds.
+  sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
+  def approximate_backlog_age=(value)
+  end
+
+  # Approximate age of the oldest task in the backlog based on the creation time of the task at the head of
+# the queue. Can be relied upon for scaling decisions.
+#
+# Special note for workflow task queue type: this metric does not count sticky queue tasks. However, because
+# those tasks only remain valid for a few seconds, they should not affect the result when backlog is older than
+# few seconds.
+  sig { void }
+  def clear_approximate_backlog_age
+  end
+
+  # The approximate tasks per second added to the task queue, averaging the last 30 seconds. These includes tasks
+# whether or not they were added to/dispatched from the backlog or they were dispatched immediately without going
+# to the backlog (sync-matched).
+#
+# The difference between `tasks_add_rate` and `tasks_dispatch_rate` is a reliable metric for the rate at which
+# backlog grows/shrinks.
+#
+# Note: the actual tasks delivered to the workers may significantly be higher than the numbers reported by
+# tasks_add_rate, because:
+# - Tasks can be sent to workers without going to the task queue. This is called Eager dispatch. Eager dispatch is
+#   enable for activities by default in the latest SDKs.
+# - Tasks going to Sticky queue are not accounted for. Note that, typically, only the first workflow task of each
+#   workflow goes to a normal queue, and the rest workflow tasks go to the Sticky queue associated with a specific
+#   worker instance.
+  sig { returns(Float) }
+  def tasks_add_rate
+  end
+
+  # The approximate tasks per second added to the task queue, averaging the last 30 seconds. These includes tasks
+# whether or not they were added to/dispatched from the backlog or they were dispatched immediately without going
+# to the backlog (sync-matched).
+#
+# The difference between `tasks_add_rate` and `tasks_dispatch_rate` is a reliable metric for the rate at which
+# backlog grows/shrinks.
+#
+# Note: the actual tasks delivered to the workers may significantly be higher than the numbers reported by
+# tasks_add_rate, because:
+# - Tasks can be sent to workers without going to the task queue. This is called Eager dispatch. Eager dispatch is
+#   enable for activities by default in the latest SDKs.
+# - Tasks going to Sticky queue are not accounted for. Note that, typically, only the first workflow task of each
+#   workflow goes to a normal queue, and the rest workflow tasks go to the Sticky queue associated with a specific
+#   worker instance.
+  sig { params(value: Float).void }
+  def tasks_add_rate=(value)
+  end
+
+  # The approximate tasks per second added to the task queue, averaging the last 30 seconds. These includes tasks
+# whether or not they were added to/dispatched from the backlog or they were dispatched immediately without going
+# to the backlog (sync-matched).
+#
+# The difference between `tasks_add_rate` and `tasks_dispatch_rate` is a reliable metric for the rate at which
+# backlog grows/shrinks.
+#
+# Note: the actual tasks delivered to the workers may significantly be higher than the numbers reported by
+# tasks_add_rate, because:
+# - Tasks can be sent to workers without going to the task queue. This is called Eager dispatch. Eager dispatch is
+#   enable for activities by default in the latest SDKs.
+# - Tasks going to Sticky queue are not accounted for. Note that, typically, only the first workflow task of each
+#   workflow goes to a normal queue, and the rest workflow tasks go to the Sticky queue associated with a specific
+#   worker instance.
+  sig { void }
+  def clear_tasks_add_rate
+  end
+
+  # The approximate tasks per second dispatched from the task queue, averaging the last 30 seconds. These includes
+# tasks whether or not they were added to/dispatched from the backlog or they were dispatched immediately without
+# going to the backlog (sync-matched).
+#
+# The difference between `tasks_add_rate` and `tasks_dispatch_rate` is a reliable metric for the rate at which
+# backlog grows/shrinks.
+#
+# Note: the actual tasks delivered to the workers may significantly be higher than the numbers reported by
+# tasks_dispatch_rate, because:
+# - Tasks can be sent to workers without going to the task queue. This is called Eager dispatch. Eager dispatch is
+#   enable for activities by default in the latest SDKs.
+# - Tasks going to Sticky queue are not accounted for. Note that, typically, only the first workflow task of each
+#   workflow goes to a normal queue, and the rest workflow tasks go to the Sticky queue associated with a specific
+#   worker instance.
+  sig { returns(Float) }
+  def tasks_dispatch_rate
+  end
+
+  # The approximate tasks per second dispatched from the task queue, averaging the last 30 seconds. These includes
+# tasks whether or not they were added to/dispatched from the backlog or they were dispatched immediately without
+# going to the backlog (sync-matched).
+#
+# The difference between `tasks_add_rate` and `tasks_dispatch_rate` is a reliable metric for the rate at which
+# backlog grows/shrinks.
+#
+# Note: the actual tasks delivered to the workers may significantly be higher than the numbers reported by
+# tasks_dispatch_rate, because:
+# - Tasks can be sent to workers without going to the task queue. This is called Eager dispatch. Eager dispatch is
+#   enable for activities by default in the latest SDKs.
+# - Tasks going to Sticky queue are not accounted for. Note that, typically, only the first workflow task of each
+#   workflow goes to a normal queue, and the rest workflow tasks go to the Sticky queue associated with a specific
+#   worker instance.
+  sig { params(value: Float).void }
+  def tasks_dispatch_rate=(value)
+  end
+
+  # The approximate tasks per second dispatched from the task queue, averaging the last 30 seconds. These includes
+# tasks whether or not they were added to/dispatched from the backlog or they were dispatched immediately without
+# going to the backlog (sync-matched).
+#
+# The difference between `tasks_add_rate` and `tasks_dispatch_rate` is a reliable metric for the rate at which
+# backlog grows/shrinks.
+#
+# Note: the actual tasks delivered to the workers may significantly be higher than the numbers reported by
+# tasks_dispatch_rate, because:
+# - Tasks can be sent to workers without going to the task queue. This is called Eager dispatch. Eager dispatch is
+#   enable for activities by default in the latest SDKs.
+# - Tasks going to Sticky queue are not accounted for. Note that, typically, only the first workflow task of each
+#   workflow goes to a normal queue, and the rest workflow tasks go to the Sticky queue associated with a specific
+#   worker instance.
+  sig { void }
+  def clear_tasks_dispatch_rate
+  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::TaskQueue::V1::TaskQueueStats) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueStats).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueStats) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueStats, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# Deprecated. Use `InternalTaskQueueStatus`. This is kept until `DescribeTaskQueue` supports legacy behavior.
+class Temporalio::Api::TaskQueue::V1::TaskQueueStatus
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      backlog_count_hint: T.nilable(Integer),
+      read_level: T.nilable(Integer),
+      ack_level: T.nilable(Integer),
+      rate_per_second: T.nilable(Float),
+      task_id_block: T.nilable(Temporalio::Api::TaskQueue::V1::TaskIdBlock)
+    ).void
+  end
+  def initialize(
+    backlog_count_hint: 0,
+    read_level: 0,
+    ack_level: 0,
+    rate_per_second: 0.0,
+    task_id_block: nil
+  )
+  end
+
+  sig { returns(Integer) }
+  def backlog_count_hint
+  end
+
+  sig { params(value: Integer).void }
+  def backlog_count_hint=(value)
+  end
+
+  sig { void }
+  def clear_backlog_count_hint
+  end
+
+  sig { returns(Integer) }
+  def read_level
+  end
+
+  sig { params(value: Integer).void }
+  def read_level=(value)
+  end
+
+  sig { void }
+  def clear_read_level
+  end
+
+  sig { returns(Integer) }
+  def ack_level
+  end
+
+  sig { params(value: Integer).void }
+  def ack_level=(value)
+  end
+
+  sig { void }
+  def clear_ack_level
+  end
+
+  sig { returns(Float) }
+  def rate_per_second
+  end
+
+  sig { params(value: Float).void }
+  def rate_per_second=(value)
+  end
+
+  sig { void }
+  def clear_rate_per_second
+  end
+
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskIdBlock)) }
+  def task_id_block
+  end
+
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskIdBlock)).void }
+  def task_id_block=(value)
+  end
+
+  sig { void }
+  def clear_task_id_block
+  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::TaskQueue::V1::TaskQueueStatus) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueStatus).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueStatus) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueStatus, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::TaskIdBlock
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      start_id: T.nilable(Integer),
+      end_id: T.nilable(Integer)
+    ).void
+  end
+  def initialize(
+    start_id: 0,
+    end_id: 0
+  )
+  end
+
+  sig { returns(Integer) }
+  def start_id
+  end
+
+  sig { params(value: Integer).void }
+  def start_id=(value)
+  end
+
+  sig { void }
+  def clear_start_id
+  end
+
+  sig { returns(Integer) }
+  def end_id
+  end
+
+  sig { params(value: Integer).void }
+  def end_id=(value)
+  end
+
+  sig { void }
+  def clear_end_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::TaskQueue::V1::TaskIdBlock) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskIdBlock).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskIdBlock) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskIdBlock, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::TaskQueuePartitionMetadata
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      key: T.nilable(String),
+      owner_host_name: T.nilable(String)
+    ).void
+  end
+  def initialize(
+    key: "",
+    owner_host_name: ""
+  )
+  end
+
+  sig { returns(String) }
+  def key
+  end
+
+  sig { params(value: String).void }
+  def key=(value)
+  end
+
+  sig { void }
+  def clear_key
+  end
+
+  sig { returns(String) }
+  def owner_host_name
+  end
+
+  sig { params(value: String).void }
+  def owner_host_name=(value)
+  end
+
+  sig { void }
+  def clear_owner_host_name
+  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::TaskQueue::V1::TaskQueuePartitionMetadata) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueuePartitionMetadata).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueuePartitionMetadata) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueuePartitionMetadata, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::PollerInfo
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      last_access_time: T.nilable(Google::Protobuf::Timestamp),
+      identity: T.nilable(String),
+      rate_per_second: T.nilable(Float),
+      worker_version_capabilities: T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities),
+      deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)
+    ).void
+  end
+  def initialize(
+    last_access_time: nil,
+    identity: "",
+    rate_per_second: 0.0,
+    worker_version_capabilities: nil,
+    deployment_options: nil
+  )
+  end
+
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def last_access_time
+  end
+
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def last_access_time=(value)
+  end
+
+  sig { void }
+  def clear_last_access_time
+  end
+
+  sig { returns(String) }
+  def identity
+  end
+
+  sig { params(value: String).void }
+  def identity=(value)
+  end
+
+  sig { void }
+  def clear_identity
+  end
+
+  sig { returns(Float) }
+  def rate_per_second
+  end
+
+  sig { params(value: Float).void }
+  def rate_per_second=(value)
+  end
+
+  sig { void }
+  def clear_rate_per_second
+  end
+
+  # If a worker has opted into the worker versioning feature while polling, its capabilities will
+# appear here.
+# Deprecated. Replaced by deployment_options.
+  sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities)) }
+  def worker_version_capabilities
+  end
+
+  # If a worker has opted into the worker versioning feature while polling, its capabilities will
+# appear here.
+# Deprecated. Replaced by deployment_options.
+  sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities)).void }
+  def worker_version_capabilities=(value)
+  end
+
+  # If a worker has opted into the worker versioning feature while polling, its capabilities will
+# appear here.
+# Deprecated. Replaced by deployment_options.
+  sig { void }
+  def clear_worker_version_capabilities
+  end
+
+  # Worker deployment options that SDK sent to server.
+  sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) }
+  def deployment_options
+  end
+
+  # Worker deployment options that SDK sent to server.
+  sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void }
+  def deployment_options=(value)
+  end
+
+  # Worker deployment options that SDK sent to server.
+  sig { void }
+  def clear_deployment_options
+  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::TaskQueue::V1::PollerInfo) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::PollerInfo).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::PollerInfo) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::PollerInfo, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::StickyExecutionAttributes
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      worker_task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue),
+      schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration)
+    ).void
+  end
+  def initialize(
+    worker_task_queue: nil,
+    schedule_to_start_timeout: nil
+  )
+  end
+
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) }
+  def worker_task_queue
+  end
+
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void }
+  def worker_task_queue=(value)
+  end
+
+  sig { void }
+  def clear_worker_task_queue
+  end
+
+  # (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "to" is used to indicate interval. --)
+  sig { returns(T.nilable(Google::Protobuf::Duration)) }
+  def schedule_to_start_timeout
+  end
+
+  # (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "to" is used to indicate interval. --)
+  sig { params(value: T.nilable(Google::Protobuf::Duration)).void }
+  def schedule_to_start_timeout=(value)
+  end
+
+  # (-- api-linter: core::0140::prepositions=disabled
+#     aip.dev/not-precedent: "to" is used to indicate interval. --)
+  sig { void }
+  def clear_schedule_to_start_timeout
+  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::TaskQueue::V1::StickyExecutionAttributes) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::StickyExecutionAttributes).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::StickyExecutionAttributes) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::StickyExecutionAttributes, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# Used by the worker versioning APIs, represents an unordered set of one or more versions which are
+# considered to be compatible with each other. Currently the versions are always worker build IDs.
+class Temporalio::Api::TaskQueue::V1::CompatibleVersionSet
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      build_ids: T.nilable(T::Array[String])
+    ).void
+  end
+  def initialize(
+    build_ids: []
+  )
+  end
+
+  # All the compatible versions, unordered, except for the last element, which is considered the set "default".
+  sig { returns(T::Array[String]) }
+  def build_ids
+  end
+
+  # All the compatible versions, unordered, except for the last element, which is considered the set "default".
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def build_ids=(value)
+  end
+
+  # All the compatible versions, unordered, except for the last element, which is considered the set "default".
+  sig { void }
+  def clear_build_ids
+  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::TaskQueue::V1::CompatibleVersionSet) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::CompatibleVersionSet).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::CompatibleVersionSet) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::CompatibleVersionSet, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# Reachability of tasks for a worker on a single task queue.
+class Temporalio::Api::TaskQueue::V1::TaskQueueReachability
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      task_queue: T.nilable(String),
+      reachability: T.nilable(T::Array[T.any(Symbol, String, Integer)])
+    ).void
+  end
+  def initialize(
+    task_queue: "",
+    reachability: []
+  )
+  end
+
+  sig { returns(String) }
+  def task_queue
+  end
+
+  sig { params(value: String).void }
+  def task_queue=(value)
+  end
+
+  sig { void }
+  def clear_task_queue
+  end
+
+  # Task reachability for a worker in a single task queue.
+# See the TaskReachability docstring for information about each enum variant.
+# If reachability is empty, this worker is considered unreachable in this task queue.
+  sig { returns(T::Array[T.any(Symbol, Integer)]) }
+  def reachability
+  end
+
+  # Task reachability for a worker in a single task queue.
+# See the TaskReachability docstring for information about each enum variant.
+# If reachability is empty, this worker is considered unreachable in this task queue.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def reachability=(value)
+  end
+
+  # Task reachability for a worker in a single task queue.
+# See the TaskReachability docstring for information about each enum variant.
+# If reachability is empty, this worker is considered unreachable in this task queue.
+  sig { void }
+  def clear_reachability
+  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::TaskQueue::V1::TaskQueueReachability) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueReachability).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueReachability) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueReachability, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# Reachability of tasks for a worker by build id, in one or more task queues.
+class Temporalio::Api::TaskQueue::V1::BuildIdReachability
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      build_id: T.nilable(String),
+      task_queue_reachability: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueReachability)])
+    ).void
+  end
+  def initialize(
+    build_id: "",
+    task_queue_reachability: []
+  )
+  end
+
+  # A build id or empty if unversioned.
+  sig { returns(String) }
+  def build_id
+  end
+
+  # A build id or empty if unversioned.
+  sig { params(value: String).void }
+  def build_id=(value)
+  end
+
+  # A build id or empty if unversioned.
+  sig { void }
+  def clear_build_id
+  end
+
+  # Reachability per task queue.
+  sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueReachability)]) }
+  def task_queue_reachability
+  end
+
+  # Reachability per task queue.
+  sig { params(value: ::Google::Protobuf::RepeatedField).void }
+  def task_queue_reachability=(value)
+  end
+
+  # Reachability per task queue.
+  sig { void }
+  def clear_task_queue_reachability
+  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::TaskQueue::V1::BuildIdReachability) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::BuildIdReachability).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::BuildIdReachability) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::BuildIdReachability, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::RampByPercentage
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      ramp_percentage: T.nilable(Float)
+    ).void
+  end
+  def initialize(
+    ramp_percentage: 0.0
+  )
+  end
+
+  # Acceptable range is [0,100).
+  sig { returns(Float) }
+  def ramp_percentage
+  end
+
+  # Acceptable range is [0,100).
+  sig { params(value: Float).void }
+  def ramp_percentage=(value)
+  end
+
+  # Acceptable range is [0,100).
+  sig { void }
+  def clear_ramp_percentage
+  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::TaskQueue::V1::RampByPercentage) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::RampByPercentage).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::RampByPercentage) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::RampByPercentage, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# Assignment rules are applied to *new* Workflow and Activity executions at
+# schedule time to assign them to a Build ID.
+#
+# Assignment rules will not be used in the following cases:
+#    - Child Workflows or Continue-As-New Executions who inherit their
+#      parent/previous Workflow's assigned Build ID (by setting the
+#      `inherit_build_id` flag - default behavior in SDKs when the same Task Queue
+#      is used.)
+#    - An Activity that inherits the assigned Build ID of its Workflow (by
+#      setting the `use_workflow_build_id` flag - default behavior in SDKs
+#      when the same Task Queue is used.)
+#
+# In absence of (applicable) redirect rules (`CompatibleBuildIdRedirectRule`s)
+# the task will be dispatched to Workers of the Build ID determined by the
+# assignment rules (or inherited). Otherwise, the final Build ID will be
+# determined by the redirect rules.
+#
+# Once a Workflow completes its first Workflow Task in a particular Build ID it
+# stays in that Build ID regardless of changes to assignment rules. Redirect
+# rules can be used to move the workflow to another compatible Build ID.
+#
+# When using Worker Versioning on a Task Queue, in the steady state,
+# there should typically be a single assignment rule to send all new executions
+# to the latest Build ID. Existence of at least one such "unconditional"
+# rule at all times is enforces by the system, unless the `force` flag is used
+# by the user when replacing/deleting these rules (for exceptional cases).
+#
+# During a deployment, one or more additional rules can be added to assign a
+# subset of the tasks to a new Build ID based on a "ramp percentage".
+#
+# When there are multiple assignment rules for a Task Queue, the rules are
+# evaluated in order, starting from index 0. The first applicable rule will be
+# applied and the rest will be ignored.
+#
+# In the event that no assignment rule is applicable on a task (or the Task
+# Queue is simply not versioned), the tasks will be dispatched to an
+# unversioned Worker.
+class Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      target_build_id: T.nilable(String),
+      percentage_ramp: T.nilable(Temporalio::Api::TaskQueue::V1::RampByPercentage)
+    ).void
+  end
+  def initialize(
+    target_build_id: "",
+    percentage_ramp: nil
+  )
+  end
+
+  sig { returns(String) }
+  def target_build_id
+  end
+
+  sig { params(value: String).void }
+  def target_build_id=(value)
+  end
+
+  sig { void }
+  def clear_target_build_id
+  end
+
+  # This ramp is useful for gradual Blue/Green deployments (and similar)
+# where you want to send a certain portion of the traffic to the target
+# Build ID.
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::RampByPercentage)) }
+  def percentage_ramp
+  end
+
+  # This ramp is useful for gradual Blue/Green deployments (and similar)
+# where you want to send a certain portion of the traffic to the target
+# Build ID.
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::RampByPercentage)).void }
+  def percentage_ramp=(value)
+  end
+
+  # This ramp is useful for gradual Blue/Green deployments (and similar)
+# where you want to send a certain portion of the traffic to the target
+# Build ID.
+  sig { void }
+  def clear_percentage_ramp
+  end
+
+  sig { returns(T.nilable(Symbol)) }
+  def ramp
+  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::TaskQueue::V1::BuildIdAssignmentRule) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# These rules apply to tasks assigned to a particular Build ID
+# (`source_build_id`) to redirect them to another *compatible* Build ID
+# (`target_build_id`).
+#
+# It is user's responsibility to ensure that the target Build ID is compatible
+# with the source Build ID (e.g. by using the Patching API).
+#
+# Most deployments are not expected to need these rules, however following
+# situations can greatly benefit from redirects:
+#  - Need to move long-running Workflow Executions from an old Build ID to a
+#    newer one.
+#  - Need to hotfix some broken or stuck Workflow Executions.
+#
+# In steady state, redirect rules are beneficial when dealing with old
+# Executions ran on now-decommissioned Build IDs:
+#  - To redirecting the Workflow Queries to the current (compatible) Build ID.
+#  - To be able to Reset an old Execution so it can run on the current
+#    (compatible) Build ID.
+#
+# Redirect rules can be chained.
+class Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      source_build_id: T.nilable(String),
+      target_build_id: T.nilable(String)
+    ).void
+  end
+  def initialize(
+    source_build_id: "",
+    target_build_id: ""
+  )
+  end
+
+  sig { returns(String) }
+  def source_build_id
+  end
+
+  sig { params(value: String).void }
+  def source_build_id=(value)
+  end
+
+  sig { void }
+  def clear_source_build_id
+  end
+
+  # Target Build ID must be compatible with the Source Build ID; that is it
+# must be able to process event histories made by the Source Build ID by
+# using [Patching](https://docs.temporal.io/workflows#patching) or other
+# means.
+  sig { returns(String) }
+  def target_build_id
+  end
+
+  # Target Build ID must be compatible with the Source Build ID; that is it
+# must be able to process event histories made by the Source Build ID by
+# using [Patching](https://docs.temporal.io/workflows#patching) or other
+# means.
+  sig { params(value: String).void }
+  def target_build_id=(value)
+  end
+
+  # Target Build ID must be compatible with the Source Build ID; that is it
+# must be able to process event histories made by the Source Build ID by
+# using [Patching](https://docs.temporal.io/workflows#patching) or other
+# means.
+  sig { void }
+  def clear_target_build_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::TaskQueue::V1::CompatibleBuildIdRedirectRule) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::TimestampedBuildIdAssignmentRule
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      rule: T.nilable(Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule),
+      create_time: T.nilable(Google::Protobuf::Timestamp)
+    ).void
+  end
+  def initialize(
+    rule: nil,
+    create_time: nil
+  )
+  end
+
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule)) }
+  def rule
+  end
+
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule)).void }
+  def rule=(value)
+  end
+
+  sig { void }
+  def clear_rule
+  end
+
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def create_time
+  end
+
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def create_time=(value)
+  end
+
+  sig { void }
+  def clear_create_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::TaskQueue::V1::TimestampedBuildIdAssignmentRule) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TimestampedBuildIdAssignmentRule).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TimestampedBuildIdAssignmentRule) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TimestampedBuildIdAssignmentRule, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      rule: T.nilable(Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule),
+      create_time: T.nilable(Google::Protobuf::Timestamp)
+    ).void
+  end
+  def initialize(
+    rule: nil,
+    create_time: nil
+  )
+  end
+
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule)) }
+  def rule
+  end
+
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule)).void }
+  def rule=(value)
+  end
+
+  sig { void }
+  def clear_rule
+  end
+
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def create_time
+  end
+
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def create_time=(value)
+  end
+
+  sig { void }
+  def clear_create_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::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::PollerGroupInfo
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      id: T.nilable(String),
+      weight: T.nilable(Float)
+    ).void
+  end
+  def initialize(
+    id: "",
+    weight: 0.0
+  )
+  end
+
+  sig { returns(String) }
+  def id
+  end
+
+  sig { params(value: String).void }
+  def id=(value)
+  end
+
+  sig { void }
+  def clear_id
+  end
+
+  sig { returns(Float) }
+  def weight
+  end
+
+  sig { params(value: Float).void }
+  def weight=(value)
+  end
+
+  sig { void }
+  def clear_weight
+  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::TaskQueue::V1::PollerGroupInfo) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::PollerGroupInfo).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::PollerGroupInfo) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::PollerGroupInfo, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+# Attached to task responses to give hints to the SDK about how it may adjust its number of
+# pollers.
+class Temporalio::Api::TaskQueue::V1::PollerScalingDecision
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      poll_request_delta_suggestion: T.nilable(Integer)
+    ).void
+  end
+  def initialize(
+    poll_request_delta_suggestion: 0
+  )
+  end
+
+  # How many poll requests to suggest should be added or removed, if any. As of now, server only
+# scales up or down by 1. However, SDKs should allow for other values (while staying within
+# defined min/max).
+#
+# The SDK is free to ignore this suggestion, EX: making more polls would not make sense because
+# all slots are already occupied.
+  sig { returns(Integer) }
+  def poll_request_delta_suggestion
+  end
+
+  # How many poll requests to suggest should be added or removed, if any. As of now, server only
+# scales up or down by 1. However, SDKs should allow for other values (while staying within
+# defined min/max).
+#
+# The SDK is free to ignore this suggestion, EX: making more polls would not make sense because
+# all slots are already occupied.
+  sig { params(value: Integer).void }
+  def poll_request_delta_suggestion=(value)
+  end
+
+  # How many poll requests to suggest should be added or removed, if any. As of now, server only
+# scales up or down by 1. However, SDKs should allow for other values (while staying within
+# defined min/max).
+#
+# The SDK is free to ignore this suggestion, EX: making more polls would not make sense because
+# all slots are already occupied.
+  sig { void }
+  def clear_poll_request_delta_suggestion
+  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::TaskQueue::V1::PollerScalingDecision) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::PollerScalingDecision).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::PollerScalingDecision) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::PollerScalingDecision, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::RateLimit
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      requests_per_second: T.nilable(Float)
+    ).void
+  end
+  def initialize(
+    requests_per_second: 0.0
+  )
+  end
+
+  # Zero is a valid rate limit.
+  sig { returns(Float) }
+  def requests_per_second
+  end
+
+  # Zero is a valid rate limit.
+  sig { params(value: Float).void }
+  def requests_per_second=(value)
+  end
+
+  # Zero is a valid rate limit.
+  sig { void }
+  def clear_requests_per_second
+  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::TaskQueue::V1::RateLimit) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::RateLimit).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::RateLimit) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::RateLimit, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::ConfigMetadata
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      reason: T.nilable(String),
+      update_identity: T.nilable(String),
+      update_time: T.nilable(Google::Protobuf::Timestamp)
+    ).void
+  end
+  def initialize(
+    reason: "",
+    update_identity: "",
+    update_time: nil
+  )
+  end
+
+  # Reason for why the config was set.
+  sig { returns(String) }
+  def reason
+  end
+
+  # Reason for why the config was set.
+  sig { params(value: String).void }
+  def reason=(value)
+  end
+
+  # Reason for why the config was set.
+  sig { void }
+  def clear_reason
+  end
+
+  # Identity of the last updater.
+# Set by the request's identity field.
+  sig { returns(String) }
+  def update_identity
+  end
+
+  # Identity of the last updater.
+# Set by the request's identity field.
+  sig { params(value: String).void }
+  def update_identity=(value)
+  end
+
+  # Identity of the last updater.
+# Set by the request's identity field.
+  sig { void }
+  def clear_update_identity
+  end
+
+  # Time of the last update.
+  sig { returns(T.nilable(Google::Protobuf::Timestamp)) }
+  def update_time
+  end
+
+  # Time of the last update.
+  sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void }
+  def update_time=(value)
+  end
+
+  # Time of the last update.
+  sig { void }
+  def clear_update_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::TaskQueue::V1::ConfigMetadata) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::ConfigMetadata).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::ConfigMetadata) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::ConfigMetadata, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::RateLimitConfig
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      rate_limit: T.nilable(Temporalio::Api::TaskQueue::V1::RateLimit),
+      metadata: T.nilable(Temporalio::Api::TaskQueue::V1::ConfigMetadata)
+    ).void
+  end
+  def initialize(
+    rate_limit: nil,
+    metadata: nil
+  )
+  end
+
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::RateLimit)) }
+  def rate_limit
+  end
+
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::RateLimit)).void }
+  def rate_limit=(value)
+  end
+
+  sig { void }
+  def clear_rate_limit
+  end
+
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::ConfigMetadata)) }
+  def metadata
+  end
+
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::ConfigMetadata)).void }
+  def metadata=(value)
+  end
+
+  sig { void }
+  def clear_metadata
+  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::TaskQueue::V1::RateLimitConfig) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::RateLimitConfig).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::RateLimitConfig) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::RateLimitConfig, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end
+
+class Temporalio::Api::TaskQueue::V1::TaskQueueConfig
+  include ::Google::Protobuf::MessageExts
+  extend ::Google::Protobuf::MessageExts::ClassMethods
+
+  sig do
+    params(
+      queue_rate_limit: T.nilable(Temporalio::Api::TaskQueue::V1::RateLimitConfig),
+      fairness_keys_rate_limit_default: T.nilable(Temporalio::Api::TaskQueue::V1::RateLimitConfig),
+      fairness_weight_overrides: T.nilable(T::Hash[String, Float])
+    ).void
+  end
+  def initialize(
+    queue_rate_limit: nil,
+    fairness_keys_rate_limit_default: nil,
+    fairness_weight_overrides: ::Google::Protobuf::Map.new(:string, :float)
+  )
+  end
+
+  # Unless modified, this is the system-defined rate limit.
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::RateLimitConfig)) }
+  def queue_rate_limit
+  end
+
+  # Unless modified, this is the system-defined rate limit.
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::RateLimitConfig)).void }
+  def queue_rate_limit=(value)
+  end
+
+  # Unless modified, this is the system-defined rate limit.
+  sig { void }
+  def clear_queue_rate_limit
+  end
+
+  # If set, each individual fairness key will be limited to this rate, scaled by the weight of the fairness key.
+  sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::RateLimitConfig)) }
+  def fairness_keys_rate_limit_default
+  end
+
+  # If set, each individual fairness key will be limited to this rate, scaled by the weight of the fairness key.
+  sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::RateLimitConfig)).void }
+  def fairness_keys_rate_limit_default=(value)
+  end
+
+  # If set, each individual fairness key will be limited to this rate, scaled by the weight of the fairness key.
+  sig { void }
+  def clear_fairness_keys_rate_limit_default
+  end
+
+  # If set, overrides the fairness weights for the corresponding fairness keys.
+  sig { returns(T::Hash[String, Float]) }
+  def fairness_weight_overrides
+  end
+
+  # If set, overrides the fairness weights for the corresponding fairness keys.
+  sig { params(value: ::Google::Protobuf::Map).void }
+  def fairness_weight_overrides=(value)
+  end
+
+  # If set, overrides the fairness weights for the corresponding fairness keys.
+  sig { void }
+  def clear_fairness_weight_overrides
+  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::TaskQueue::V1::TaskQueueConfig) }
+  def self.decode(str)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueConfig).returns(String) }
+  def self.encode(msg)
+  end
+
+  sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TaskQueue::V1::TaskQueueConfig) }
+  def self.decode_json(str, **kw)
+  end
+
+  sig { params(msg: Temporalio::Api::TaskQueue::V1::TaskQueueConfig, kw: T.untyped).returns(String) }
+  def self.encode_json(msg, **kw)
+  end
+
+  sig { returns(::Google::Protobuf::Descriptor) }
+  def self.descriptor
+  end
+end