diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index cd3b2f58..3eb7aa23 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -63,6 +63,12 @@ jobs: with: go-version: stable + - name: Install protoc-gen-rbi + shell: bash + run: | + go install "github.com/coinbase/protoc-gen-rbi@$(tr -d '\n' < .protoc-gen-rbi-version)" + echo "$(go env GOPATH)/bin" >> "$GITHUB_PATH" + - name: Install protoc uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3 with: @@ -104,6 +110,35 @@ jobs: run: bundle exec rake TESTOPTS="--verbose" + - name: Test Ruby with Sorbet runtime assertions + if: ${{ matrix.os == 'ubuntu-latest' }} + working-directory: ./temporalio + # Timeout just in case there's a hanging part in rake + timeout-minutes: 10 + # Set env vars for cloud tests. If secrets aren't present, tests will be skipped. + env: + # For mTLS tests + TEMPORAL_CLOUD_MTLS_TEST_TARGET_HOST: ${{ vars.TEMPORAL_CLIENT_NAMESPACE }}.tmprl.cloud:7233 + TEMPORAL_CLOUD_MTLS_TEST_NAMESPACE: ${{ vars.TEMPORAL_CLIENT_NAMESPACE }} + TEMPORAL_CLOUD_MTLS_TEST_CLIENT_CERT: ${{ secrets.TEMPORAL_CLIENT_CERT }} + TEMPORAL_CLOUD_MTLS_TEST_CLIENT_KEY: ${{ secrets.TEMPORAL_CLIENT_KEY }} + + # For API key tests + TEMPORAL_CLOUD_API_KEY_TEST_TARGET_HOST: us-east-1.aws.api.temporal.io:7233 + TEMPORAL_CLOUD_API_KEY_TEST_NAMESPACE: ${{ vars.TEMPORAL_CLIENT_NAMESPACE }} + TEMPORAL_CLOUD_API_KEY_TEST_API_KEY: ${{ secrets.TEMPORAL_CLIENT_CLOUD_API_KEY }} + + # For cloud ops tests + TEMPORAL_CLOUD_OPS_TEST_TARGET_HOST: saas-api.tmprl.cloud:443 + TEMPORAL_CLOUD_OPS_TEST_NAMESPACE: ${{ vars.TEMPORAL_CLIENT_NAMESPACE }} + TEMPORAL_CLOUD_OPS_TEST_API_KEY: ${{ secrets.TEMPORAL_CLIENT_CLOUD_API_KEY }} + TEMPORAL_CLOUD_OPS_TEST_API_VERSION: 2024-05-13-00 + + # Enable Sorbet runtime type checking to verify RBI accuracy. + TEMPORAL_SORBET_RUNTIME_CHECK: "1" + + run: bundle exec rake test TESTOPTS="--verbose" + - name: Deploy docs # Only deploy on main merge, not in PRs if: ${{ github.ref == 'refs/heads/main' && matrix.docsTarget }} diff --git a/.protoc-gen-rbi-version b/.protoc-gen-rbi-version new file mode 100644 index 00000000..8308b63a --- /dev/null +++ b/.protoc-gen-rbi-version @@ -0,0 +1 @@ +v0.1.1 diff --git a/README.md b/README.md index 4962b304..176eb2d5 100644 --- a/README.md +++ b/README.md @@ -1412,6 +1412,21 @@ Now can run `steep`: bundle exec rake steep +### Type Signatures (Experimental) + +The SDK ships two sets of type signatures: + +* **RBS**: Maintained throughout development of the SDK, but only recently made public. +* **RBI**: Sorbet types maintained in parallel with the RBS signatures. Must be + updated manually when the RBS changes (see below). +* **Generated protobuf RBI** (`rbi/temporalio/api/`) -- Sorbet types generated from protobuf files in parallel with + generated protobuf RBS. + +The RBI signatures are validated at runtime by running the test suite, which applies every RBI +signature to the real implementation at runtime via `SigApplicator`. This catches drift between the RBI and actual code. + +This is yet another reason to ensure any changes you make have test coverage. + ### Proto Generation Run: @@ -1420,3 +1435,9 @@ Run: `proto:generate` now requires `protoc >= 34.0` because we generate RBS alongside the generated Ruby protobuf files. + +We use `protoc-gen-rbi` to generated protobuf RBI. + +It can be installed via `go install`: + + go install github.com/coinbase/protoc-gen-rbi@$(cat ../.protoc-gen-rbi-version) diff --git a/temporalio/Gemfile b/temporalio/Gemfile index f957ea43..31c6936f 100644 --- a/temporalio/Gemfile +++ b/temporalio/Gemfile @@ -21,10 +21,12 @@ group :development do gem 'opentelemetry-sdk' gem 'rake' gem 'rake-compiler' + gem 'rbi' gem 'rbs', '~> 3.10' gem 'rb_sys', '~> 0.9' gem 'rdoc' gem 'rubocop' + gem 'sorbet-runtime' gem 'sqlite3' gem 'steep', '~> 1.10' gem 'yard' diff --git a/temporalio/extra/payload_visitor_gen.rb b/temporalio/extra/payload_visitor_gen.rb index b9ab9821..d767be7f 100644 --- a/temporalio/extra/payload_visitor_gen.rb +++ b/temporalio/extra/payload_visitor_gen.rb @@ -190,6 +190,72 @@ def google_protobuf_any: (untyped value) -> void TEXT end + # Generate file Sorbet signature. + # + # @return [String] File signature. + def gen_rbi_code + method_defs = payload_methods.filter_map do |_, method_hash| + next if method_hash[:fields].empty? + + <<~TEXT + sig { params(value: Object).void } + def #{method_name_from_desc(method_hash[:desc])}(value); end + TEXT + end.sort + + <<~TEXT + # typed: true + + # Generated code. DO NOT EDIT! + + class Temporalio::Api::PayloadVisitor + extend T::Sig + + sig do + params( + on_enter: T.nilable(T.proc.params(value: Object).returns(Object)), + on_exit: T.nilable(T.proc.params(value: Object).returns(Object)), + skip_search_attributes: T::Boolean, + traverse_any: T::Boolean, + block: T.proc.params(value: Object).returns(Object) + ).void + end + def initialize( + on_enter: T.unsafe(nil), + on_exit: T.unsafe(nil), + skip_search_attributes: T.unsafe(false), + traverse_any: T.unsafe(false), + &block + ); end + + sig { params(value: Object).returns(NilClass) } + def run(value); end + + sig { params(value: Object).void } + def _run_activation(value); end + + sig { params(value: Object).void } + def _run_activation_completion(value); end + + private + + sig { params(name: String).returns(String) } + def method_name_from_proto_name(name); end + + sig { params(value: Object).returns(Object) } + def api_common_v1_payload(value); end + + sig { params(value: Object).returns(Object) } + def api_common_v1_payload_repeated(value); end + + sig { params(value: Object).void } + def google_protobuf_any(value); end + + #{method_defs.join("\n").gsub("\n", "\n ")} + end + TEXT + end + private def payload_methods diff --git a/temporalio/extra/proto_gen.rb b/temporalio/extra/proto_gen.rb index 4abc6bb5..1baaa330 100644 --- a/temporalio/extra/proto_gen.rb +++ b/temporalio/extra/proto_gen.rb @@ -7,7 +7,9 @@ # Generator for the proto files. class ProtoGen PROTOC_VERSION_FILE = File.expand_path('../../.protoc-version', __dir__) + PROTOC_GEN_RBI_VERSION_FILE = File.expand_path('../../.protoc-gen-rbi-version', __dir__) MINIMUM_PROTOC_VERSION = Gem::Version.new(File.read(PROTOC_VERSION_FILE).strip) + PROTOC_GEN_RBI_VERSION = File.read(PROTOC_GEN_RBI_VERSION_FILE).strip SERVICE_DEFINITIONS = [ { require_path: './lib/temporalio/api/workflowservice/v1/service', @@ -50,12 +52,15 @@ class ProtoGen 'lib/temporalio/api', 'lib/temporalio/internal/bridge/api', 'lib/protoc-gen-openapiv2', + 'rbi/temporalio/api', + 'rbi/temporalio/internal/bridge/api', 'sig/temporalio/api', 'sig/temporalio/internal/bridge/api', 'sig/protoc-gen-openapiv2', *SERVICE_DEFINITIONS.flat_map do |service| [ "lib/temporalio/client/connection/#{service[:file_name]}.rb", + "rbi/temporalio/client/connection/#{service[:file_name]}.rbi", "sig/temporalio/client/connection/#{service[:file_name]}.rbs" ] end, @@ -71,11 +76,13 @@ def self.generated_paths def run FileUtils.rm_rf('lib/temporalio/api') FileUtils.rm_rf('lib/protoc-gen-openapiv2') + FileUtils.rm_rf('rbi/temporalio/api') FileUtils.rm_rf('sig/temporalio/api') FileUtils.rm_rf('sig/temporalio/internal/bridge/api') FileUtils.rm_rf('sig/protoc-gen-openapiv2') verify_protoc! + verify_protoc_gen_rbi! generate_api_protos(Dir.glob('ext/sdk-core/crates/common/protos/api_upstream/**/*.proto').reject do |proto| proto.include?('google') @@ -99,7 +106,7 @@ def run def generate_api_protos(api_protos, extra_proto_paths: []) # Generate API to temp dir and move FileUtils.rm_rf('tmp-proto') - FileUtils.mkdir_p(['tmp-proto/ruby', 'tmp-proto/rbs']) + FileUtils.mkdir_p(['tmp-proto/rbi', 'tmp-proto/rbs', 'tmp-proto/ruby']) system( protoc_command, *google_proto_include_flags, @@ -108,6 +115,8 @@ def generate_api_protos(api_protos, extra_proto_paths: []) '--proto_path=ext/sdk-core/crates/common/protos/testsrv_upstream', '--proto_path=ext/additional_protos', *extra_proto_paths, + "--plugin=protoc-gen-rbi=#{protoc_gen_rbi_command}", + '--rbi_out=grpc=false:tmp-proto/rbi', '--ruby_out=tmp-proto/ruby', '--rbs_out=tmp-proto/rbs', *api_protos, @@ -130,8 +139,11 @@ def generate_api_protos(api_protos, extra_proto_paths: []) end # Move from temp dir and remove temp dir + Dir.glob('tmp-proto/rbi/temporal/api/**/*.rbi') { |path| normalize_generated_rbi!(path) } Dir.glob('tmp-proto/rbs/temporal/api/**/*.rbs') { |path| normalize_generated_rbs!(path) } FileUtils.cp_r('tmp-proto/ruby/temporal/api', 'lib/temporalio') + FileUtils.mkdir_p('rbi/temporalio') + FileUtils.cp_r('tmp-proto/rbi/temporal/api', 'rbi/temporalio') FileUtils.mkdir_p('sig/temporalio') FileUtils.cp_r('tmp-proto/rbs/temporal/api', 'sig/temporalio') FileUtils.rm_rf('tmp-proto') @@ -139,11 +151,13 @@ def generate_api_protos(api_protos, extra_proto_paths: []) def generate_openapiv2_protos FileUtils.rm_rf('tmp-proto') - FileUtils.mkdir_p(['tmp-proto/ruby', 'tmp-proto/rbs']) + FileUtils.mkdir_p(['tmp-proto/rbi', 'tmp-proto/rbs', 'tmp-proto/ruby']) system( protoc_command, *google_proto_include_flags, '--proto_path=ext/sdk-core/crates/common/protos', + "--plugin=protoc-gen-rbi=#{protoc_gen_rbi_command}", + '--rbi_out=grpc=false:tmp-proto/rbi', '--ruby_out=tmp-proto/ruby', '--rbs_out=tmp-proto/rbs', *Dir.glob('ext/sdk-core/crates/common/protos/protoc-gen-openapiv2/**/*.proto'), @@ -158,9 +172,11 @@ def generate_openapiv2_protos File.write(path, content) FileUtils.mv(path, path.sub('_pb', '')) end + Dir.glob('tmp-proto/rbi/protoc-gen-openapiv2/**/*.rbi') { |path| normalize_generated_rbi!(path) } Dir.glob('tmp-proto/rbs/protoc-gen-openapiv2/**/*.rbs') { |path| normalize_generated_rbs!(path) } - FileUtils.mkdir_p(['lib/temporalio/api', 'sig/temporalio/api']) + FileUtils.mkdir_p(['lib/temporalio/api', 'rbi/temporalio/api', 'sig/temporalio/api']) FileUtils.cp_r('tmp-proto/ruby/protoc-gen-openapiv2', 'lib/temporalio/api/protoc_gen_openapiv2') + FileUtils.cp_r('tmp-proto/rbi/protoc-gen-openapiv2', 'rbi/temporalio/api/protoc_gen_openapiv2') FileUtils.cp_r('tmp-proto/rbs/protoc-gen-openapiv2', 'sig/temporalio/api/protoc_gen_openapiv2') FileUtils.rm_rf('tmp-proto') end @@ -193,6 +209,29 @@ def generate_import_helper_files require 'temporalio/api/operatorservice/v1/request_response' TEXT ) + FileUtils.mkdir_p( + [ + 'rbi/temporalio/api/cloud', + 'rbi/temporalio/api/operatorservice', + 'rbi/temporalio/api/workflowservice' + ] + ) + FileUtils.mkdir_p( + [ + 'sig/temporalio/api/cloud', + 'sig/temporalio/api/operatorservice', + 'sig/temporalio/api/workflowservice' + ] + ) + File.write('rbi/temporalio/api/cloud/cloudservice.rbi', generated_empty_module_rbi('Temporalio::Api::Cloud::CloudService')) + File.write('rbi/temporalio/api/operatorservice.rbi', generated_empty_module_rbi('Temporalio::Api::OperatorService')) + File.write('rbi/temporalio/api/workflowservice.rbi', generated_empty_module_rbi('Temporalio::Api::WorkflowService')) + File.write( + 'sig/temporalio/api/cloud/cloudservice.rbs', + generated_empty_module_rbs(%w[Temporalio Api Cloud CloudService]) + ) + File.write('sig/temporalio/api/operatorservice.rbs', generated_empty_module_rbs(%w[Temporalio Api OperatorService])) + File.write('sig/temporalio/api/workflowservice.rbs', generated_empty_module_rbs(%w[Temporalio Api WorkflowService])) File.write( 'lib/temporalio/api.rb', <<~TEXT @@ -314,6 +353,34 @@ def #{rpc}: ( end TEXT end + + # Open file to generate RBI code + FileUtils.mkdir_p('rbi/temporalio/client/connection') + File.open("rbi/temporalio/client/connection/#{file_name}.rbi", 'w') do |file| + file.puts <<~TEXT + # typed: false + # frozen_string_literal: true + + # Generated code. DO NOT EDIT! + + class Temporalio::Client::Connection::#{class_name} < ::Temporalio::Client::Connection::Service + extend T::Sig + + sig { params(connection: Temporalio::Client::Connection).void } + def initialize(connection); end + TEXT + + desc.each do |method| + rpc = method.name.gsub(/([A-Z])/, '_\1').downcase.delete_prefix('_') + file.puts <<-TEXT + + sig { params(request: #{method.input_type.msgclass}, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(#{method.output_type.msgclass}) } + def #{rpc}(request, rpc_options: T.unsafe(nil)); end + TEXT + end + + file.puts 'end' + end end def generate_rust_client_file @@ -375,14 +442,17 @@ def generate_rust_match_arm(file:, qualified_service_name:, service_enum:, trait def generate_core_protos FileUtils.rm_rf('lib/temporalio/internal/bridge/api') + FileUtils.rm_rf('rbi/temporalio/internal/bridge/api') # Generate API to temp dir FileUtils.rm_rf('tmp-proto') - FileUtils.mkdir_p(['tmp-proto/ruby', 'tmp-proto/rbs']) + FileUtils.mkdir_p(['tmp-proto/rbi', 'tmp-proto/ruby', 'tmp-proto/rbs']) system( protoc_command, *google_proto_include_flags, '--proto_path=ext/sdk-core/crates/common/protos/api_upstream', '--proto_path=ext/sdk-core/crates/common/protos/local', + "--plugin=protoc-gen-rbi=#{protoc_gen_rbi_command}", + '--rbi_out=grpc=false:tmp-proto/rbi', '--ruby_out=tmp-proto/ruby', '--rbs_out=tmp-proto/rbs', *Dir.glob('ext/sdk-core/crates/common/protos/local/**/*.proto'), @@ -400,9 +470,12 @@ def generate_core_protos FileUtils.mv(path, path.sub('_pb', '')) end # Move from temp dir and remove temp dir + Dir.glob('tmp-proto/rbi/temporal/sdk/**/*.rbi') { |path| normalize_generated_rbi!(path) } Dir.glob('tmp-proto/rbs/temporal/sdk/**/*.rbs') { |path| normalize_generated_rbs!(path) } FileUtils.mkdir_p('lib/temporalio/internal/bridge/api') FileUtils.cp_r(Dir.glob('tmp-proto/ruby/temporal/sdk/core/*'), 'lib/temporalio/internal/bridge/api') + FileUtils.mkdir_p('rbi/temporalio/internal/bridge/api') + FileUtils.cp_r(Dir.glob('tmp-proto/rbi/temporal/sdk/core/*'), 'rbi/temporalio/internal/bridge/api') FileUtils.mkdir_p('sig/temporalio/internal/bridge/api') FileUtils.cp_r(Dir.glob('tmp-proto/rbs/temporal/sdk/core/*'), 'sig/temporalio/internal/bridge/api') FileUtils.rm_rf('tmp-proto') @@ -412,10 +485,36 @@ def generate_payload_visitor require_relative 'payload_visitor_gen' gen = PayloadVisitorGen.new File.write('lib/temporalio/api/payload_visitor.rb', gen.gen_file_code) + FileUtils.mkdir_p('rbi/temporalio/api') + File.write('rbi/temporalio/api/payload_visitor.rbi', gen.gen_rbi_code) FileUtils.mkdir_p('sig/temporalio/api') File.write('sig/temporalio/api/payload_visitor.rbs', gen.gen_rbs_code) end + def generated_empty_module_rbi(class_name) + <<~TEXT + # typed: true + + # Generated code. DO NOT EDIT! + + module #{class_name}; end + TEXT + end + + def generated_empty_module_rbs(names) + indent = +'' + body = +'' + names.each do |name| + body << "#{indent}module #{name}\n" + indent << ' ' + end + names.reverse_each do |_name| + indent = indent[0...-2] + body << "#{indent}end\n" + end + body + end + def protoc_command ENV.fetch('PROTOC', 'protoc') end @@ -425,6 +524,40 @@ def google_proto_include_flags include_dir ? ["--proto_path=#{include_dir}"] : [] end + def protoc_gen_rbi_command + @protoc_gen_rbi_command ||= begin + env_path = ENV.fetch('PROTOC_GEN_RBI', nil) + if env_path + raise "PROTOC_GEN_RBI is set to #{env_path.inspect}, but it is not executable" unless executable_file?(env_path) + + env_path + else + find_executable('protoc-gen-rbi') || begin + home_path = File.join(Dir.home, 'go', 'bin', 'protoc-gen-rbi') + executable_file?(home_path) ? home_path : nil + end + end + end + end + + def verify_protoc_gen_rbi! + return if protoc_gen_rbi_command + + raise "protoc-gen-rbi #{PROTOC_GEN_RBI_VERSION} is required and was not found. " \ + "Install with: go install github.com/coinbase/protoc-gen-rbi@#{PROTOC_GEN_RBI_VERSION}" + end + + def find_executable(command) + ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).filter_map do |dir| + path = File.join(dir, command) + path if executable_file?(path) + end.first + end + + def executable_file?(path) + !path.empty? && File.file?(path) && File.executable?(path) + end + def protoc_version @protoc_version ||= begin version_output, status = Open3.capture2(protoc_command, '--version') @@ -484,4 +617,14 @@ def normalize_generated_rbs!(path) # Keep RBS filenames aligned with the Ruby files we already rename away from the `_pb` suffix. FileUtils.mv(path, path.sub('_pb', '')) end + + def normalize_generated_rbi!(path) + content = File.binread(path) + content = content.gsub("\r\n", "\n").gsub(/[ \t]+(?=\n)/, '').gsub(/[ \t]+\z/, '') + File.write(path, content) + + # Keep RBI filenames aligned with the Ruby files we already rename away from the `_pb` suffix. + new_path = path.sub('_pb', '') + FileUtils.mv(path, new_path) unless new_path == path + end end diff --git a/temporalio/lib/temporalio/worker/activity_executor/fiber.rb b/temporalio/lib/temporalio/worker/activity_executor/fiber.rb index 9c57a2df..ad4f7508 100644 --- a/temporalio/lib/temporalio/worker/activity_executor/fiber.rb +++ b/temporalio/lib/temporalio/worker/activity_executor/fiber.rb @@ -23,7 +23,7 @@ def initialize_activity(defn) end # @see ActivityExecutor.initialize_activity - def execute_activity(_defn, &) + def execute_activity(defn, &) # rubocop:disable Lint/UnusedMethodArgument ::Fiber.schedule(&) end diff --git a/temporalio/lib/temporalio/worker/activity_executor/thread_pool.rb b/temporalio/lib/temporalio/worker/activity_executor/thread_pool.rb index 04ad7616..7db37994 100644 --- a/temporalio/lib/temporalio/worker/activity_executor/thread_pool.rb +++ b/temporalio/lib/temporalio/worker/activity_executor/thread_pool.rb @@ -20,7 +20,7 @@ def initialize(thread_pool = Worker::ThreadPool.default) # rubocop:disable Lint/ end # @see ActivityExecutor.execute_activity - def execute_activity(_defn, &) + def execute_activity(defn, &) # rubocop:disable Lint/UnusedMethodArgument @thread_pool.execute(&) end diff --git a/temporalio/rbi/google/protobuf.rbi b/temporalio/rbi/google/protobuf.rbi new file mode 100644 index 00000000..9cbc8a09 --- /dev/null +++ b/temporalio/rbi/google/protobuf.rbi @@ -0,0 +1,25 @@ +# typed: false +# frozen_string_literal: true + +# Minimal shim for google-protobuf types referenced by generated proto RBI files. + +module Google + module Protobuf + module MessageExts + module ClassMethods; end + end + + class AbstractMessage; end + class Descriptor; end + class EnumDescriptor; end + class RepeatedField; end + class Map; end + + class Any; end + class DoubleValue; end + class Duration; end + class Empty; end + class FieldMask; end + class Timestamp; end + end +end diff --git a/temporalio/rbi/temporalio.rbi b/temporalio/rbi/temporalio.rbi new file mode 100644 index 00000000..34b9630c --- /dev/null +++ b/temporalio/rbi/temporalio.rbi @@ -0,0 +1,8 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio + VERSION = T.let(T.unsafe(nil), String) +end diff --git a/temporalio/rbi/temporalio/activity.rbi b/temporalio/rbi/temporalio/activity.rbi new file mode 100644 index 00000000..fbf3fa74 --- /dev/null +++ b/temporalio/rbi/temporalio/activity.rbi @@ -0,0 +1,6 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Activity; end diff --git a/temporalio/rbi/temporalio/activity/cancellation_details.rbi b/temporalio/rbi/temporalio/activity/cancellation_details.rbi new file mode 100644 index 00000000..92db831d --- /dev/null +++ b/temporalio/rbi/temporalio/activity/cancellation_details.rbi @@ -0,0 +1,36 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Activity::CancellationDetails + sig do + params( + gone_from_server: T::Boolean, + cancel_requested: T::Boolean, + timed_out: T::Boolean, + worker_shutdown: T::Boolean, + paused: T::Boolean, + reset: T::Boolean + ).void + end + def initialize(gone_from_server: false, cancel_requested: false, timed_out: false, worker_shutdown: false, paused: false, reset: false); end + + sig { returns(T::Boolean) } + def gone_from_server?; end + + sig { returns(T::Boolean) } + def cancel_requested?; end + + sig { returns(T::Boolean) } + def timed_out?; end + + sig { returns(T::Boolean) } + def worker_shutdown?; end + + sig { returns(T::Boolean) } + def paused?; end + + sig { returns(T::Boolean) } + def reset?; end +end diff --git a/temporalio/rbi/temporalio/activity/complete_async_error.rbi b/temporalio/rbi/temporalio/activity/complete_async_error.rbi new file mode 100644 index 00000000..93cfae85 --- /dev/null +++ b/temporalio/rbi/temporalio/activity/complete_async_error.rbi @@ -0,0 +1,6 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Activity::CompleteAsyncError < ::Temporalio::Error; end diff --git a/temporalio/rbi/temporalio/activity/context.rbi b/temporalio/rbi/temporalio/activity/context.rbi new file mode 100644 index 00000000..9abf150f --- /dev/null +++ b/temporalio/rbi/temporalio/activity/context.rbi @@ -0,0 +1,45 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Activity::Context + sig { returns(Temporalio::Activity::Context) } + def self.current; end + + sig { returns(T.nilable(Temporalio::Activity::Context)) } + def self.current_or_nil; end + + sig { returns(T::Boolean) } + def self.exist?; end + + sig { returns(Temporalio::Activity::Info) } + def info; end + + sig { returns(T.nilable(Temporalio::Activity::Definition)) } + def instance; end + + sig { params(details: T.nilable(Object), detail_hints: T.nilable(T::Array[Object])).void } + def heartbeat(*details, detail_hints: nil); end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T.nilable(Temporalio::Activity::CancellationDetails)) } + def cancellation_details; end + + sig { returns(Temporalio::Cancellation) } + def worker_shutdown_cancellation; end + + sig { returns(Temporalio::Converters::PayloadConverter) } + def payload_converter; end + + sig { returns(Temporalio::ScopedLogger) } + def logger; end + + sig { returns(Temporalio::Metric::Meter) } + def metric_meter; end + + sig { returns(Temporalio::Client) } + def client; end +end diff --git a/temporalio/rbi/temporalio/activity/definition.rbi b/temporalio/rbi/temporalio/activity/definition.rbi new file mode 100644 index 00000000..66796434 --- /dev/null +++ b/temporalio/rbi/temporalio/activity/definition.rbi @@ -0,0 +1,77 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Activity::Definition + sig { params(args: Object).returns(Object) } + def execute(*args); end + + class << self + protected + + sig { params(name: T.any(String, Symbol)).void } + def activity_name(name); end + + sig { params(executor_name: Symbol).void } + def activity_executor(executor_name); end + + sig { params(cancel_raise: T::Boolean).void } + def activity_cancel_raise(cancel_raise); end + + sig { params(value: T::Boolean).void } + def activity_dynamic(value = true); end + + sig { params(value: T::Boolean).void } + def activity_raw_args(value = true); end + + sig { params(hints: Object).void } + def activity_arg_hint(*hints); end + + sig { params(hint: T.nilable(Object)).void } + def activity_result_hint(hint); end + end +end + +class Temporalio::Activity::Definition::Info + sig do + params( + name: T.nilable(T.any(String, Symbol)), + instance: T.nilable(T.any(Object, Proc)), + executor: Symbol, + cancel_raise: T::Boolean, + raw_args: T::Boolean, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + block: T.nilable(T.proc.params(arg0: Object).returns(Object)) + ).void + end + def initialize(name:, instance: nil, executor: :default, cancel_raise: true, raw_args: false, arg_hints: nil, result_hint: nil, &block); end + + sig { params(activity: T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)).returns(Temporalio::Activity::Definition::Info) } + def self.from_activity(activity); end + + sig { returns(T.nilable(T.any(String, Symbol))) } + attr_reader :name + + sig { returns(T.nilable(T.any(Object, Proc))) } + attr_reader :instance + + sig { returns(Proc) } + attr_reader :proc + + sig { returns(Symbol) } + attr_reader :executor + + sig { returns(T::Boolean) } + attr_reader :cancel_raise + + sig { returns(T::Boolean) } + attr_reader :raw_args + + sig { returns(T.nilable(T::Array[Object])) } + attr_reader :arg_hints + + sig { returns(T.nilable(Object)) } + attr_reader :result_hint +end diff --git a/temporalio/rbi/temporalio/activity/info.rbi b/temporalio/rbi/temporalio/activity/info.rbi new file mode 100644 index 00000000..ca3de231 --- /dev/null +++ b/temporalio/rbi/temporalio/activity/info.rbi @@ -0,0 +1,102 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Activity::Info < ::Data + sig do + params( + activity_id: String, + activity_type: String, + attempt: Integer, + current_attempt_scheduled_time: Time, + heartbeat_timeout: T.nilable(Float), + local: T::Boolean, + priority: T.nilable(Temporalio::Priority), + raw_heartbeat_details: T::Array[Temporalio::Converters::RawValue], + retry_policy: T.nilable(Temporalio::RetryPolicy), + schedule_to_close_timeout: T.nilable(Float), + scheduled_time: Time, + start_to_close_timeout: T.nilable(Float), + started_time: Time, + task_queue: String, + task_token: String, + workflow_id: String, + workflow_namespace: String, + workflow_run_id: String, + workflow_type: String + ).void + end + def initialize(activity_id:, activity_type:, attempt:, current_attempt_scheduled_time:, heartbeat_timeout:, local:, priority:, raw_heartbeat_details:, retry_policy:, schedule_to_close_timeout:, scheduled_time:, start_to_close_timeout:, started_time:, task_queue:, task_token:, workflow_id:, workflow_namespace:, workflow_run_id:, workflow_type:); end + + sig { returns(String) } + def activity_id; end + + sig { returns(String) } + def activity_type; end + + sig { returns(Integer) } + def attempt; end + + sig { returns(Time) } + def current_attempt_scheduled_time; end + + sig { params(hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) } + def heartbeat_details(hints: nil); end + + sig { returns(T.nilable(Numeric)) } + def heartbeat_timeout; end + + sig { returns(T::Boolean) } + def local?; end + + sig { returns(Temporalio::Priority) } + def priority; end + + sig { returns(T::Array[Temporalio::Converters::RawValue]) } + def raw_heartbeat_details; end + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + def retry_policy; end + + sig { returns(T.nilable(Numeric)) } + def schedule_to_close_timeout; end + + sig { returns(Time) } + def scheduled_time; end + + sig { returns(T.nilable(Numeric)) } + def start_to_close_timeout; end + + sig { returns(Time) } + def started_time; end + + sig { returns(String) } + def task_queue; end + + sig { returns(String) } + def task_token; end + + sig { returns(String) } + def workflow_id; end + + sig { returns(String) } + def workflow_namespace; end + + sig { returns(String) } + def workflow_run_id; end + + sig { returns(String) } + def workflow_type; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Activity::Info) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + + sig { params(args: T.untyped).returns(Temporalio::Activity::Info) } + def new(*args); end + end +end diff --git a/temporalio/rbi/temporalio/api.rbi b/temporalio/rbi/temporalio/api.rbi new file mode 100644 index 00000000..ee77460c --- /dev/null +++ b/temporalio/rbi/temporalio/api.rbi @@ -0,0 +1,10 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Api; end + +module Temporalio::Api::Common; end + +module Temporalio::Api::Common::V1; end diff --git a/temporalio/rbi/temporalio/api/activity/v1/message.rbi b/temporalio/rbi/temporalio/api/activity/v1/message.rbi new file mode 100644 index 00000000..453b92cf --- /dev/null +++ b/temporalio/rbi/temporalio/api/activity/v1/message.rbi @@ -0,0 +1,1390 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/activity/v1/message.proto +# typed: strict + +# The outcome of a completed activity execution: either a successful result or a failure. +class Temporalio::Api::Activity::V1::ActivityExecutionOutcome + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result: T.nilable(Temporalio::Api::Common::V1::Payloads), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + result: nil, + failure: nil + ) + end + + # The result if the activity completed successfully. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def result + end + + # The result if the activity completed successfully. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def result=(value) + end + + # The result if the activity completed successfully. + sig { void } + def clear_result + end + + # The failure if the activity completed unsuccessfully. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The failure if the activity completed unsuccessfully. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The failure if the activity completed unsuccessfully. + sig { void } + def clear_failure + end + + sig { returns(T.nilable(Symbol)) } + def value + 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::Activity::V1::ActivityExecutionOutcome) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Activity::V1::ActivityExecutionOutcome).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Activity::V1::ActivityExecutionOutcome) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Activity::V1::ActivityExecutionOutcome, 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::Activity::V1::ActivityOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + heartbeat_timeout: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + priority: T.nilable(Temporalio::Api::Common::V1::Priority) + ).void + end + def initialize( + task_queue: nil, + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + heartbeat_timeout: nil, + retry_policy: nil, + priority: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- 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_close_timeout + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- 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_close_timeout=(value) + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` or workflow execution timeout if not +# specified. +# +# (-- 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 + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` or workflow execution timeout if not +# specified. +# +# (-- 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 + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` or workflow execution timeout if not +# specified. +# +# (-- 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 + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- 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 start_to_close_timeout=(value) + end + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def heartbeat_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def heartbeat_timeout=(value) + end + + # Maximum permitted time between successful worker heartbeats. + sig { void } + def clear_heartbeat_timeout + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { void } + def clear_retry_policy + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { void } + def clear_priority + 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::Activity::V1::ActivityOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Activity::V1::ActivityOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Activity::V1::ActivityOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Activity::V1::ActivityOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Information about a standalone activity. +class Temporalio::Api::Activity::V1::ActivityExecutionInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_id: T.nilable(String), + run_id: T.nilable(String), + activity_type: T.nilable(Temporalio::Api::Common::V1::ActivityType), + status: T.nilable(T.any(Symbol, String, Integer)), + run_state: T.nilable(T.any(Symbol, String, Integer)), + task_queue: T.nilable(String), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + heartbeat_timeout: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + heartbeat_details: T.nilable(Temporalio::Api::Common::V1::Payloads), + last_heartbeat_time: T.nilable(Google::Protobuf::Timestamp), + last_started_time: T.nilable(Google::Protobuf::Timestamp), + attempt: T.nilable(Integer), + execution_duration: T.nilable(Google::Protobuf::Duration), + schedule_time: T.nilable(Google::Protobuf::Timestamp), + expiration_time: T.nilable(Google::Protobuf::Timestamp), + close_time: T.nilable(Google::Protobuf::Timestamp), + last_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + last_worker_identity: T.nilable(String), + current_retry_interval: T.nilable(Google::Protobuf::Duration), + last_attempt_complete_time: T.nilable(Google::Protobuf::Timestamp), + next_attempt_schedule_time: T.nilable(Google::Protobuf::Timestamp), + last_deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + state_transition_count: T.nilable(Integer), + state_size_bytes: T.nilable(Integer), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + header: T.nilable(Temporalio::Api::Common::V1::Header), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + canceled_reason: T.nilable(String), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]), + total_heartbeat_count: T.nilable(Integer) + ).void + end + def initialize( + activity_id: "", + run_id: "", + activity_type: nil, + status: :ACTIVITY_EXECUTION_STATUS_UNSPECIFIED, + run_state: :PENDING_ACTIVITY_STATE_UNSPECIFIED, + task_queue: "", + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + heartbeat_timeout: nil, + retry_policy: nil, + heartbeat_details: nil, + last_heartbeat_time: nil, + last_started_time: nil, + attempt: 0, + execution_duration: nil, + schedule_time: nil, + expiration_time: nil, + close_time: nil, + last_failure: nil, + last_worker_identity: "", + current_retry_interval: nil, + last_attempt_complete_time: nil, + next_attempt_schedule_time: nil, + last_deployment_version: nil, + priority: nil, + state_transition_count: 0, + state_size_bytes: 0, + search_attributes: nil, + header: nil, + user_metadata: nil, + canceled_reason: "", + links: [], + total_heartbeat_count: 0 + ) + end + + # Unique identifier of this activity within its namespace along with run ID (below). + sig { returns(String) } + def activity_id + end + + # Unique identifier of this activity within its namespace along with run ID (below). + sig { params(value: String).void } + def activity_id=(value) + end + + # Unique identifier of this activity within its namespace along with run ID (below). + sig { void } + def clear_activity_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + # The type of the activity, a string that maps to a registered activity on a worker. + sig { returns(T.nilable(Temporalio::Api::Common::V1::ActivityType)) } + def activity_type + end + + # The type of the activity, a string that maps to a registered activity on a worker. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ActivityType)).void } + def activity_type=(value) + end + + # The type of the activity, a string that maps to a registered activity on a worker. + sig { void } + def clear_activity_type + end + + # A general status for this activity, indicates whether it is currently running or in one of the terminal statuses. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # A general status for this activity, indicates whether it is currently running or in one of the terminal statuses. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # A general status for this activity, indicates whether it is currently running or in one of the terminal statuses. + sig { void } + def clear_status + end + + # More detailed breakdown of ACTIVITY_EXECUTION_STATUS_RUNNING. + sig { returns(T.any(Symbol, Integer)) } + def run_state + end + + # More detailed breakdown of ACTIVITY_EXECUTION_STATUS_RUNNING. + sig { params(value: T.any(Symbol, String, Integer)).void } + def run_state=(value) + end + + # More detailed breakdown of ACTIVITY_EXECUTION_STATUS_RUNNING. + sig { void } + def clear_run_state + 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 + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. +# +# (-- 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_close_timeout + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. +# +# (-- 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_close_timeout=(value) + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout`. +# +# (-- 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 + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout`. +# +# (-- 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 + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout`. +# +# (-- 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 + + # Maximum time a single activity attempt is allowed to execute after being picked up by a worker. This +# timeout is always retryable. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Maximum time a single activity attempt is allowed to execute after being picked up by a worker. This +# timeout is always retryable. +# +# (-- 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 start_to_close_timeout=(value) + end + + # Maximum time a single activity attempt is allowed to execute after being picked up by a worker. This +# timeout is always retryable. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def heartbeat_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def heartbeat_timeout=(value) + end + + # Maximum permitted time between successful worker heartbeats. + sig { void } + def clear_heartbeat_timeout + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { void } + def clear_retry_policy + end + + # Details provided in the last recorded activity heartbeat. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def heartbeat_details + end + + # Details provided in the last recorded activity heartbeat. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def heartbeat_details=(value) + end + + # Details provided in the last recorded activity heartbeat. + sig { void } + def clear_heartbeat_details + end + + # Time the last heartbeat was recorded. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_heartbeat_time + end + + # Time the last heartbeat was recorded. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_heartbeat_time=(value) + end + + # Time the last heartbeat was recorded. + sig { void } + def clear_last_heartbeat_time + end + + # Time the last attempt was started. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_started_time + end + + # Time the last attempt was started. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_started_time=(value) + end + + # Time the last attempt was started. + sig { void } + def clear_last_started_time + end + + # The attempt this activity is currently on. Incremented each time a new attempt is scheduled. + sig { returns(Integer) } + def attempt + end + + # The attempt this activity is currently on. Incremented each time a new attempt is scheduled. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The attempt this activity is currently on. Incremented each time a new attempt is scheduled. + sig { void } + def clear_attempt + end + + # How long this activity has been running for, including all attempts and backoff between attempts. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def execution_duration + end + + # How long this activity has been running for, including all attempts and backoff between attempts. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def execution_duration=(value) + end + + # How long this activity has been running for, including all attempts and backoff between attempts. + sig { void } + def clear_execution_duration + end + + # Time the activity was originally scheduled via a StartActivityExecution request. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def schedule_time + end + + # Time the activity was originally scheduled via a StartActivityExecution request. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def schedule_time=(value) + end + + # Time the activity was originally scheduled via a StartActivityExecution request. + sig { void } + def clear_schedule_time + end + + # Scheduled time + schedule to close timeout. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def expiration_time + end + + # Scheduled time + schedule to close timeout. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def expiration_time=(value) + end + + # Scheduled time + schedule to close timeout. + sig { void } + def clear_expiration_time + end + + # Time when the activity transitioned to a closed state. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def close_time + end + + # Time when the activity transitioned to a closed state. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def close_time=(value) + end + + # Time when the activity transitioned to a closed state. + sig { void } + def clear_close_time + end + + # Failure details from the last failed attempt. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_failure + end + + # Failure details from the last failed attempt. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_failure=(value) + end + + # Failure details from the last failed attempt. + sig { void } + def clear_last_failure + end + + sig { returns(String) } + def last_worker_identity + end + + sig { params(value: String).void } + def last_worker_identity=(value) + end + + sig { void } + def clear_last_worker_identity + end + + # Time from the last attempt failure to the next activity retry. +# If the activity is currently running, this represents the next retry interval in case the attempt fails. +# If activity is currently backing off between attempt, this represents the current retry interval. +# If there is no next retry allowed, this field will be null. +# This interval is typically calculated from the specified retry policy, but may be modified if an activity fails +# with a retryable application failure specifying a retry delay. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def current_retry_interval + end + + # Time from the last attempt failure to the next activity retry. +# If the activity is currently running, this represents the next retry interval in case the attempt fails. +# If activity is currently backing off between attempt, this represents the current retry interval. +# If there is no next retry allowed, this field will be null. +# This interval is typically calculated from the specified retry policy, but may be modified if an activity fails +# with a retryable application failure specifying a retry delay. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def current_retry_interval=(value) + end + + # Time from the last attempt failure to the next activity retry. +# If the activity is currently running, this represents the next retry interval in case the attempt fails. +# If activity is currently backing off between attempt, this represents the current retry interval. +# If there is no next retry allowed, this field will be null. +# This interval is typically calculated from the specified retry policy, but may be modified if an activity fails +# with a retryable application failure specifying a retry delay. + sig { void } + def clear_current_retry_interval + end + + # The time when the last activity attempt completed. If activity has not been completed yet, it will be null. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_attempt_complete_time + end + + # The time when the last activity attempt completed. If activity has not been completed yet, it will be null. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_attempt_complete_time=(value) + end + + # The time when the last activity attempt completed. If activity has not been completed yet, it will be null. + sig { void } + def clear_last_attempt_complete_time + end + + # The time when the next activity attempt will be scheduled. +# If activity is currently scheduled or started, this field will be null. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def next_attempt_schedule_time + end + + # The time when the next activity attempt will be scheduled. +# If activity is currently scheduled or started, this field will be null. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def next_attempt_schedule_time=(value) + end + + # The time when the next activity attempt will be scheduled. +# If activity is currently scheduled or started, this field will be null. + sig { void } + def clear_next_attempt_schedule_time + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# If nil, the activity has not yet been dispatched or was last dispatched to an unversioned worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def last_deployment_version + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# If nil, the activity has not yet been dispatched or was last dispatched to an unversioned worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def last_deployment_version=(value) + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# If nil, the activity has not yet been dispatched or was last dispatched to an unversioned worker. + sig { void } + def clear_last_deployment_version + end + + # Priority metadata. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata. + sig { void } + def clear_priority + end + + # Incremented each time the activity's state is mutated in persistence. + sig { returns(Integer) } + def state_transition_count + end + + # Incremented each time the activity's state is mutated in persistence. + sig { params(value: Integer).void } + def state_transition_count=(value) + end + + # Incremented each time the activity's state is mutated in persistence. + sig { void } + def clear_state_transition_count + end + + # Updated once on scheduled and once on terminal status. + sig { returns(Integer) } + def state_size_bytes + end + + # Updated once on scheduled and once on terminal status. + sig { params(value: Integer).void } + def state_size_bytes=(value) + end + + # Updated once on scheduled and once on terminal status. + sig { void } + def clear_state_size_bytes + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity. + sig { void } + def clear_user_metadata + end + + # Set if activity cancelation was requested. + sig { returns(String) } + def canceled_reason + end + + # Set if activity cancelation was requested. + sig { params(value: String).void } + def canceled_reason=(value) + end + + # Set if activity cancelation was requested. + sig { void } + def clear_canceled_reason + end + + # Links to related entities, such as the entity that started this activity. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to related entities, such as the entity that started this activity. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to related entities, such as the entity that started this activity. + sig { void } + def clear_links + end + + # Total number of heartbeats recorded across all attempts of this activity, including retries. + sig { returns(Integer) } + def total_heartbeat_count + end + + # Total number of heartbeats recorded across all attempts of this activity, including retries. + sig { params(value: Integer).void } + def total_heartbeat_count=(value) + end + + # Total number of heartbeats recorded across all attempts of this activity, including retries. + sig { void } + def clear_total_heartbeat_count + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Activity::V1::ActivityExecutionInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Activity::V1::ActivityExecutionInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Activity::V1::ActivityExecutionInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Activity::V1::ActivityExecutionInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Limited activity information returned in the list response. +# When adding fields here, ensure that it is also present in ActivityExecutionInfo (note that it +# may already be present in ActivityExecutionInfo but not at the top-level). +class Temporalio::Api::Activity::V1::ActivityExecutionListInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_id: T.nilable(String), + run_id: T.nilable(String), + activity_type: T.nilable(Temporalio::Api::Common::V1::ActivityType), + schedule_time: T.nilable(Google::Protobuf::Timestamp), + close_time: T.nilable(Google::Protobuf::Timestamp), + status: T.nilable(T.any(Symbol, String, Integer)), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + task_queue: T.nilable(String), + state_transition_count: T.nilable(Integer), + state_size_bytes: T.nilable(Integer), + execution_duration: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + activity_id: "", + run_id: "", + activity_type: nil, + schedule_time: nil, + close_time: nil, + status: :ACTIVITY_EXECUTION_STATUS_UNSPECIFIED, + search_attributes: nil, + task_queue: "", + state_transition_count: 0, + state_size_bytes: 0, + execution_duration: nil + ) + end + + # A unique identifier of this activity within its namespace along with run ID (below). + sig { returns(String) } + def activity_id + end + + # A unique identifier of this activity within its namespace along with run ID (below). + sig { params(value: String).void } + def activity_id=(value) + end + + # A unique identifier of this activity within its namespace along with run ID (below). + sig { void } + def clear_activity_id + end + + # The run ID of the standalone activity. + sig { returns(String) } + def run_id + end + + # The run ID of the standalone activity. + sig { params(value: String).void } + def run_id=(value) + end + + # The run ID of the standalone activity. + sig { void } + def clear_run_id + end + + # The type of the activity, a string that maps to a registered activity on a worker. + sig { returns(T.nilable(Temporalio::Api::Common::V1::ActivityType)) } + def activity_type + end + + # The type of the activity, a string that maps to a registered activity on a worker. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ActivityType)).void } + def activity_type=(value) + end + + # The type of the activity, a string that maps to a registered activity on a worker. + sig { void } + def clear_activity_type + end + + # Time the activity was originally scheduled via a StartActivityExecution request. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def schedule_time + end + + # Time the activity was originally scheduled via a StartActivityExecution request. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def schedule_time=(value) + end + + # Time the activity was originally scheduled via a StartActivityExecution request. + sig { void } + def clear_schedule_time + end + + # If the activity is in a terminal status, this field represents the time the activity transitioned to that status. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def close_time + end + + # If the activity is in a terminal status, this field represents the time the activity transitioned to that status. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def close_time=(value) + end + + # If the activity is in a terminal status, this field represents the time the activity transitioned to that status. + sig { void } + def clear_close_time + end + + # Only scheduled and terminal statuses appear here. More detailed information in PendingActivityInfo but not +# available in the list response. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # Only scheduled and terminal statuses appear here. More detailed information in PendingActivityInfo but not +# available in the list response. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # Only scheduled and terminal statuses appear here. More detailed information in PendingActivityInfo but not +# available in the list response. + sig { void } + def clear_status + end + + # Search attributes from the start request. + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # Search attributes from the start request. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # Search attributes from the start request. + sig { void } + def clear_search_attributes + end + + # The task queue this activity was scheduled on when it was originally started, updated on activity options update. + sig { returns(String) } + def task_queue + end + + # The task queue this activity was scheduled on when it was originally started, updated on activity options update. + sig { params(value: String).void } + def task_queue=(value) + end + + # The task queue this activity was scheduled on when it was originally started, updated on activity options update. + sig { void } + def clear_task_queue + end + + # Updated on terminal status. + sig { returns(Integer) } + def state_transition_count + end + + # Updated on terminal status. + sig { params(value: Integer).void } + def state_transition_count=(value) + end + + # Updated on terminal status. + sig { void } + def clear_state_transition_count + end + + # Updated once on scheduled and once on terminal status. + sig { returns(Integer) } + def state_size_bytes + end + + # Updated once on scheduled and once on terminal status. + sig { params(value: Integer).void } + def state_size_bytes=(value) + end + + # Updated once on scheduled and once on terminal status. + sig { void } + def clear_state_size_bytes + end + + # The difference between close time and scheduled time. +# This field is only populated if the activity is closed. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def execution_duration + end + + # The difference between close time and scheduled time. +# This field is only populated if the activity is closed. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def execution_duration=(value) + end + + # The difference between close time and scheduled time. +# This field is only populated if the activity is closed. + sig { void } + def clear_execution_duration + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Activity::V1::ActivityExecutionListInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Activity::V1::ActivityExecutionListInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Activity::V1::ActivityExecutionListInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Activity::V1::ActivityExecutionListInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# CallbackInfo contains the state of an attached activity callback. +class Temporalio::Api::Activity::V1::CallbackInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + trigger: T.nilable(Temporalio::Api::Activity::V1::CallbackInfo::Trigger), + info: T.nilable(Temporalio::Api::Callback::V1::CallbackInfo) + ).void + end + def initialize( + trigger: nil, + info: nil + ) + end + + # Trigger for this callback. + sig { returns(T.nilable(Temporalio::Api::Activity::V1::CallbackInfo::Trigger)) } + def trigger + end + + # Trigger for this callback. + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::CallbackInfo::Trigger)).void } + def trigger=(value) + end + + # Trigger for this callback. + sig { void } + def clear_trigger + end + + # Common callback info. + sig { returns(T.nilable(Temporalio::Api::Callback::V1::CallbackInfo)) } + def info + end + + # Common callback info. + sig { params(value: T.nilable(Temporalio::Api::Callback::V1::CallbackInfo)).void } + def info=(value) + end + + # Common callback info. + sig { void } + def clear_info + 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::Activity::V1::CallbackInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Activity::V1::CallbackInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Activity::V1::CallbackInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Activity::V1::CallbackInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Trigger for when the activity is closed. +class Temporalio::Api::Activity::V1::CallbackInfo::ActivityClosed + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Activity::V1::CallbackInfo::ActivityClosed) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Activity::V1::CallbackInfo::ActivityClosed).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Activity::V1::CallbackInfo::ActivityClosed) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Activity::V1::CallbackInfo::ActivityClosed, 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::Activity::V1::CallbackInfo::Trigger + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_closed: T.nilable(Temporalio::Api::Activity::V1::CallbackInfo::ActivityClosed) + ).void + end + def initialize( + activity_closed: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Activity::V1::CallbackInfo::ActivityClosed)) } + def activity_closed + end + + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::CallbackInfo::ActivityClosed)).void } + def activity_closed=(value) + end + + sig { void } + def clear_activity_closed + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Activity::V1::CallbackInfo::Trigger) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Activity::V1::CallbackInfo::Trigger).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Activity::V1::CallbackInfo::Trigger) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Activity::V1::CallbackInfo::Trigger, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/batch/v1/message.rbi b/temporalio/rbi/temporalio/api/batch/v1/message.rbi new file mode 100644 index 00000000..9dea2ae3 --- /dev/null +++ b/temporalio/rbi/temporalio/api/batch/v1/message.rbi @@ -0,0 +1,1283 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/batch/v1/message.proto +# typed: strict + +class Temporalio::Api::Batch::V1::BatchOperationInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + job_id: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + start_time: T.nilable(Google::Protobuf::Timestamp), + close_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + job_id: "", + state: :BATCH_OPERATION_STATE_UNSPECIFIED, + start_time: nil, + close_time: nil + ) + end + + # Batch job ID + sig { returns(String) } + def job_id + end + + # Batch job ID + sig { params(value: String).void } + def job_id=(value) + end + + # Batch job ID + sig { void } + def clear_job_id + end + + # Batch operation state + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # Batch operation state + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # Batch operation state + sig { void } + def clear_state + end + + # Batch operation start time + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # Batch operation start time + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # Batch operation start time + sig { void } + def clear_start_time + end + + # Batch operation close time + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def close_time + end + + # Batch operation close time + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def close_time=(value) + end + + # Batch operation close time + sig { void } + def clear_close_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::Batch::V1::BatchOperationInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationTermination sends terminate requests to batch workflows. +# Keep the parameter in sync with temporal.api.workflowservice.v1.TerminateWorkflowExecutionRequest. +# Ignore first_execution_run_id because this is used for single workflow operation. +class Temporalio::Api::Batch::V1::BatchOperationTermination + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String) + ).void + end + def initialize( + details: nil, + identity: "" + ) + end + + # Serialized value(s) to provide to the termination event + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + # Serialized value(s) to provide to the termination event + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + # Serialized value(s) to provide to the termination event + sig { void } + def clear_details + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + 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::Batch::V1::BatchOperationTermination) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationTermination).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationTermination) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationTermination, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationSignal sends signals to batch workflows. +# Keep the parameter in sync with temporal.api.workflowservice.v1.SignalWorkflowExecutionRequest. +class Temporalio::Api::Batch::V1::BatchOperationSignal + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + signal: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + header: T.nilable(Temporalio::Api::Common::V1::Header), + identity: T.nilable(String) + ).void + end + def initialize( + signal: "", + input: nil, + header: nil, + identity: "" + ) + end + + # The workflow author-defined name of the signal to send to the workflow + sig { returns(String) } + def signal + end + + # The workflow author-defined name of the signal to send to the workflow + sig { params(value: String).void } + def signal=(value) + end + + # The workflow author-defined name of the signal to send to the workflow + sig { void } + def clear_signal + end + + # Serialized value(s) to provide with the signal + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized value(s) to provide with the signal + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized value(s) to provide with the signal + sig { void } + def clear_input + end + + # Headers that are passed with the signal to the processing workflow. +# These can include things like auth or tracing tokens. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Headers that are passed with the signal to the processing workflow. +# These can include things like auth or tracing tokens. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Headers that are passed with the signal to the processing workflow. +# These can include things like auth or tracing tokens. + sig { void } + def clear_header + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + 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::Batch::V1::BatchOperationSignal) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationSignal).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationSignal) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationSignal, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationCancellation sends cancel requests to batch workflows. +# Keep the parameter in sync with temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionRequest. +# Ignore first_execution_run_id because this is used for single workflow operation. +class Temporalio::Api::Batch::V1::BatchOperationCancellation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String) + ).void + end + def initialize( + identity: "" + ) + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + 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::Batch::V1::BatchOperationCancellation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationCancellation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationCancellation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationCancellation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationDeletion sends deletion requests to batch workflows. +# Keep the parameter in sync with temporal.api.workflowservice.v1.DeleteWorkflowExecutionRequest. +class Temporalio::Api::Batch::V1::BatchOperationDeletion + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String) + ).void + end + def initialize( + identity: "" + ) + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + 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::Batch::V1::BatchOperationDeletion) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationDeletion).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationDeletion) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationDeletion, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationReset sends reset requests to batch workflows. +# Keep the parameter in sync with temporal.api.workflowservice.v1.ResetWorkflowExecutionRequest. +class Temporalio::Api::Batch::V1::BatchOperationReset + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + options: T.nilable(Temporalio::Api::Common::V1::ResetOptions), + reset_type: T.nilable(T.any(Symbol, String, Integer)), + reset_reapply_type: T.nilable(T.any(Symbol, String, Integer)), + post_reset_operations: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation)]) + ).void + end + def initialize( + identity: "", + options: nil, + reset_type: :RESET_TYPE_UNSPECIFIED, + reset_reapply_type: :RESET_REAPPLY_TYPE_UNSPECIFIED, + post_reset_operations: [] + ) + end + + # The identity of the worker/client. + sig { returns(String) } + def identity + end + + # The identity of the worker/client. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client. + sig { void } + def clear_identity + end + + # Describes what to reset to and how. If set, `reset_type` and `reset_reapply_type` are ignored. + sig { returns(T.nilable(Temporalio::Api::Common::V1::ResetOptions)) } + def options + end + + # Describes what to reset to and how. If set, `reset_type` and `reset_reapply_type` are ignored. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ResetOptions)).void } + def options=(value) + end + + # Describes what to reset to and how. If set, `reset_type` and `reset_reapply_type` are ignored. + sig { void } + def clear_options + end + + # Deprecated. Use `options`. + sig { returns(T.any(Symbol, Integer)) } + def reset_type + end + + # Deprecated. Use `options`. + sig { params(value: T.any(Symbol, String, Integer)).void } + def reset_type=(value) + end + + # Deprecated. Use `options`. + sig { void } + def clear_reset_type + end + + # Deprecated. Use `options`. + sig { returns(T.any(Symbol, Integer)) } + def reset_reapply_type + end + + # Deprecated. Use `options`. + sig { params(value: T.any(Symbol, String, Integer)).void } + def reset_reapply_type=(value) + end + + # Deprecated. Use `options`. + sig { void } + def clear_reset_reapply_type + end + + # Operations to perform after the workflow has been reset. These operations will be applied +# to the *new* run of the workflow execution in the order they are provided. +# All operations are applied to the workflow before the first new workflow task is generated + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation)]) } + def post_reset_operations + end + + # Operations to perform after the workflow has been reset. These operations will be applied +# to the *new* run of the workflow execution in the order they are provided. +# All operations are applied to the workflow before the first new workflow task is generated + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def post_reset_operations=(value) + end + + # Operations to perform after the workflow has been reset. These operations will be applied +# to the *new* run of the workflow execution in the order they are provided. +# All operations are applied to the workflow before the first new workflow task is generated + sig { void } + def clear_post_reset_operations + 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::Batch::V1::BatchOperationReset) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationReset).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationReset) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationReset, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationUpdateWorkflowExecutionOptions sends UpdateWorkflowExecutionOptions requests to batch workflows. +# Keep the parameters in sync with temporal.api.workflowservice.v1.UpdateWorkflowExecutionOptionsRequest. +class Temporalio::Api::Batch::V1::BatchOperationUpdateWorkflowExecutionOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + workflow_execution_options: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions), + update_mask: T.nilable(Google::Protobuf::FieldMask) + ).void + end + def initialize( + identity: "", + workflow_execution_options: nil, + update_mask: nil + ) + end + + # The identity of the worker/client. + sig { returns(String) } + def identity + end + + # The identity of the worker/client. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client. + sig { void } + def clear_identity + end + + # Update Workflow options that were originally specified via StartWorkflowExecution. Partial updates are accepted and controlled by update_mask. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions)) } + def workflow_execution_options + end + + # Update Workflow options that were originally specified via StartWorkflowExecution. Partial updates are accepted and controlled by update_mask. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions)).void } + def workflow_execution_options=(value) + end + + # Update Workflow options that were originally specified via StartWorkflowExecution. Partial updates are accepted and controlled by update_mask. + sig { void } + def clear_workflow_execution_options + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { returns(T.nilable(Google::Protobuf::FieldMask)) } + def update_mask + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { params(value: T.nilable(Google::Protobuf::FieldMask)).void } + def update_mask=(value) + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { void } + def clear_update_mask + 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::Batch::V1::BatchOperationUpdateWorkflowExecutionOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationUpdateWorkflowExecutionOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationUpdateWorkflowExecutionOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationUpdateWorkflowExecutionOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationUnpauseActivities sends unpause requests to batch workflows. +class Temporalio::Api::Batch::V1::BatchOperationUnpauseActivities + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + type: T.nilable(String), + match_all: T.nilable(T::Boolean), + reset_attempts: T.nilable(T::Boolean), + reset_heartbeat: T.nilable(T::Boolean), + jitter: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + identity: "", + type: "", + match_all: false, + reset_attempts: false, + reset_heartbeat: false, + jitter: nil + ) + end + + # The identity of the worker/client. + sig { returns(String) } + def identity + end + + # The identity of the worker/client. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client. + sig { void } + def clear_identity + end + + sig { returns(String) } + def type + end + + sig { params(value: String).void } + def type=(value) + end + + sig { void } + def clear_type + end + + sig { returns(T::Boolean) } + def match_all + end + + sig { params(value: T::Boolean).void } + def match_all=(value) + end + + sig { void } + def clear_match_all + end + + # Setting this flag will also reset the number of attempts. + sig { returns(T::Boolean) } + def reset_attempts + end + + # Setting this flag will also reset the number of attempts. + sig { params(value: T::Boolean).void } + def reset_attempts=(value) + end + + # Setting this flag will also reset the number of attempts. + sig { void } + def clear_reset_attempts + end + + # Setting this flag will also reset the heartbeat details. + sig { returns(T::Boolean) } + def reset_heartbeat + end + + # Setting this flag will also reset the heartbeat details. + sig { params(value: T::Boolean).void } + def reset_heartbeat=(value) + end + + # Setting this flag will also reset the heartbeat details. + sig { void } + def clear_reset_heartbeat + end + + # If set, the activity will start at a random time within the specified jitter +# duration, introducing variability to the start time. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def jitter + end + + # If set, the activity will start at a random time within the specified jitter +# duration, introducing variability to the start time. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def jitter=(value) + end + + # If set, the activity will start at a random time within the specified jitter +# duration, introducing variability to the start time. + sig { void } + def clear_jitter + end + + sig { returns(T.nilable(Symbol)) } + def activity + 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::Batch::V1::BatchOperationUnpauseActivities) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationUnpauseActivities).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationUnpauseActivities) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationUnpauseActivities, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationTriggerWorkflowRule sends TriggerWorkflowRule requests to batch workflows. +class Temporalio::Api::Batch::V1::BatchOperationTriggerWorkflowRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec) + ).void + end + def initialize( + identity: "", + id: "", + spec: nil + ) + end + + # The identity of the worker/client. + sig { returns(String) } + def identity + end + + # The identity of the worker/client. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client. + sig { void } + def clear_identity + end + + # ID of existing rule. + sig { returns(String) } + def id + end + + # ID of existing rule. + sig { params(value: String).void } + def id=(value) + end + + # ID of existing rule. + sig { void } + def clear_id + end + + # Rule specification to be applied to the workflow without creating a new rule. + sig { returns(T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec)) } + def spec + end + + # Rule specification to be applied to the workflow without creating a new rule. + sig { params(value: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec)).void } + def spec=(value) + end + + # Rule specification to be applied to the workflow without creating a new rule. + sig { void } + def clear_spec + end + + sig { returns(T.nilable(Symbol)) } + def rule + 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::Batch::V1::BatchOperationTriggerWorkflowRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationTriggerWorkflowRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationTriggerWorkflowRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationTriggerWorkflowRule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationResetActivities sends activity reset requests in a batch. +# NOTE: keep in sync with temporal.api.workflowservice.v1.ResetActivityRequest +class Temporalio::Api::Batch::V1::BatchOperationResetActivities + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + type: T.nilable(String), + match_all: T.nilable(T::Boolean), + reset_attempts: T.nilable(T::Boolean), + reset_heartbeat: T.nilable(T::Boolean), + keep_paused: T.nilable(T::Boolean), + jitter: T.nilable(Google::Protobuf::Duration), + restore_original_options: T.nilable(T::Boolean) + ).void + end + def initialize( + identity: "", + type: "", + match_all: false, + reset_attempts: false, + reset_heartbeat: false, + keep_paused: false, + jitter: nil, + restore_original_options: false + ) + end + + # The identity of the worker/client. + sig { returns(String) } + def identity + end + + # The identity of the worker/client. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client. + sig { void } + def clear_identity + end + + sig { returns(String) } + def type + end + + sig { params(value: String).void } + def type=(value) + end + + sig { void } + def clear_type + end + + sig { returns(T::Boolean) } + def match_all + end + + sig { params(value: T::Boolean).void } + def match_all=(value) + end + + sig { void } + def clear_match_all + end + + # Setting this flag will also reset the number of attempts. + sig { returns(T::Boolean) } + def reset_attempts + end + + # Setting this flag will also reset the number of attempts. + sig { params(value: T::Boolean).void } + def reset_attempts=(value) + end + + # Setting this flag will also reset the number of attempts. + sig { void } + def clear_reset_attempts + end + + # Setting this flag will also reset the heartbeat details. + sig { returns(T::Boolean) } + def reset_heartbeat + end + + # Setting this flag will also reset the heartbeat details. + sig { params(value: T::Boolean).void } + def reset_heartbeat=(value) + end + + # Setting this flag will also reset the heartbeat details. + sig { void } + def clear_reset_heartbeat + end + + # If activity is paused, it will remain paused after reset + sig { returns(T::Boolean) } + def keep_paused + end + + # If activity is paused, it will remain paused after reset + sig { params(value: T::Boolean).void } + def keep_paused=(value) + end + + # If activity is paused, it will remain paused after reset + sig { void } + def clear_keep_paused + end + + # If set, the activity will start at a random time within the specified jitter +# duration, introducing variability to the start time. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def jitter + end + + # If set, the activity will start at a random time within the specified jitter +# duration, introducing variability to the start time. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def jitter=(value) + end + + # If set, the activity will start at a random time within the specified jitter +# duration, introducing variability to the start time. + sig { void } + def clear_jitter + end + + # If set, the activity options will be restored to the defaults. +# Default options are then options activity was created with. +# They are part of the first ActivityTaskScheduled event. + sig { returns(T::Boolean) } + def restore_original_options + end + + # If set, the activity options will be restored to the defaults. +# Default options are then options activity was created with. +# They are part of the first ActivityTaskScheduled event. + sig { params(value: T::Boolean).void } + def restore_original_options=(value) + end + + # If set, the activity options will be restored to the defaults. +# Default options are then options activity was created with. +# They are part of the first ActivityTaskScheduled event. + sig { void } + def clear_restore_original_options + end + + sig { returns(T.nilable(Symbol)) } + def activity + 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::Batch::V1::BatchOperationResetActivities) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationResetActivities).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationResetActivities) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationResetActivities, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# BatchOperationUpdateActivityOptions sends an update-activity-options requests in a batch. +# NOTE: keep in sync with temporal.api.workflowservice.v1.UpdateActivityRequest +class Temporalio::Api::Batch::V1::BatchOperationUpdateActivityOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + type: T.nilable(String), + match_all: T.nilable(T::Boolean), + activity_options: T.nilable(Temporalio::Api::Activity::V1::ActivityOptions), + update_mask: T.nilable(Google::Protobuf::FieldMask), + restore_original: T.nilable(T::Boolean) + ).void + end + def initialize( + identity: "", + type: "", + match_all: false, + activity_options: nil, + update_mask: nil, + restore_original: false + ) + end + + # The identity of the worker/client. + sig { returns(String) } + def identity + end + + # The identity of the worker/client. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client. + sig { void } + def clear_identity + end + + sig { returns(String) } + def type + end + + sig { params(value: String).void } + def type=(value) + end + + sig { void } + def clear_type + end + + sig { returns(T::Boolean) } + def match_all + end + + sig { params(value: T::Boolean).void } + def match_all=(value) + end + + sig { void } + def clear_match_all + end + + # Update Activity options. Partial updates are accepted and controlled by update_mask. + sig { returns(T.nilable(Temporalio::Api::Activity::V1::ActivityOptions)) } + def activity_options + end + + # Update Activity options. Partial updates are accepted and controlled by update_mask. + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::ActivityOptions)).void } + def activity_options=(value) + end + + # Update Activity options. Partial updates are accepted and controlled by update_mask. + sig { void } + def clear_activity_options + end + + # Controls which fields from `activity_options` will be applied + sig { returns(T.nilable(Google::Protobuf::FieldMask)) } + def update_mask + end + + # Controls which fields from `activity_options` will be applied + sig { params(value: T.nilable(Google::Protobuf::FieldMask)).void } + def update_mask=(value) + end + + # Controls which fields from `activity_options` will be applied + sig { void } + def clear_update_mask + end + + # If set, the activity options will be restored to the default. +# Default options are then options activity was created with. +# They are part of the first ActivityTaskScheduled event. +# This flag cannot be combined with any other option; if you supply +# restore_original together with other options, the request will be rejected. + sig { returns(T::Boolean) } + def restore_original + end + + # If set, the activity options will be restored to the default. +# Default options are then options activity was created with. +# They are part of the first ActivityTaskScheduled event. +# This flag cannot be combined with any other option; if you supply +# restore_original together with other options, the request will be rejected. + sig { params(value: T::Boolean).void } + def restore_original=(value) + end + + # If set, the activity options will be restored to the default. +# Default options are then options activity was created with. +# They are part of the first ActivityTaskScheduled event. +# This flag cannot be combined with any other option; if you supply +# restore_original together with other options, the request will be rejected. + sig { void } + def clear_restore_original + end + + sig { returns(T.nilable(Symbol)) } + def activity + 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::Batch::V1::BatchOperationUpdateActivityOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationUpdateActivityOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Batch::V1::BatchOperationUpdateActivityOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Batch::V1::BatchOperationUpdateActivityOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/callback/v1/message.rbi b/temporalio/rbi/temporalio/api/callback/v1/message.rbi new file mode 100644 index 00000000..8e4eceee --- /dev/null +++ b/temporalio/rbi/temporalio/api/callback/v1/message.rbi @@ -0,0 +1,188 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/callback/v1/message.proto +# typed: strict + +# Common callback information. Specific CallbackInfo messages should embed this and may include additional fields. +class Temporalio::Api::Callback::V1::CallbackInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + callback: T.nilable(Temporalio::Api::Common::V1::Callback), + registration_time: T.nilable(Google::Protobuf::Timestamp), + state: T.nilable(T.any(Symbol, String, Integer)), + attempt: T.nilable(Integer), + last_attempt_complete_time: T.nilable(Google::Protobuf::Timestamp), + last_attempt_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + next_attempt_schedule_time: T.nilable(Google::Protobuf::Timestamp), + blocked_reason: T.nilable(String) + ).void + end + def initialize( + callback: nil, + registration_time: nil, + state: :CALLBACK_STATE_UNSPECIFIED, + attempt: 0, + last_attempt_complete_time: nil, + last_attempt_failure: nil, + next_attempt_schedule_time: nil, + blocked_reason: "" + ) + end + + # Information on how this callback should be invoked (e.g. its URL and type). + sig { returns(T.nilable(Temporalio::Api::Common::V1::Callback)) } + def callback + end + + # Information on how this callback should be invoked (e.g. its URL and type). + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Callback)).void } + def callback=(value) + end + + # Information on how this callback should be invoked (e.g. its URL and type). + sig { void } + def clear_callback + end + + # The time when the callback was registered. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def registration_time + end + + # The time when the callback was registered. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def registration_time=(value) + end + + # The time when the callback was registered. + sig { void } + def clear_registration_time + end + + # The current state of the callback. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the callback. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the callback. + sig { void } + def clear_state + end + + # The number of attempts made to deliver the callback. +# This number represents a minimum bound since the attempt is incremented after the callback request completes. + sig { returns(Integer) } + def attempt + end + + # The number of attempts made to deliver the callback. +# This number represents a minimum bound since the attempt is incremented after the callback request completes. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The number of attempts made to deliver the callback. +# This number represents a minimum bound since the attempt is incremented after the callback request completes. + sig { void } + def clear_attempt + end + + # The time when the last attempt completed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_attempt_complete_time + end + + # The time when the last attempt completed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_attempt_complete_time=(value) + end + + # The time when the last attempt completed. + sig { void } + def clear_last_attempt_complete_time + end + + # The last attempt's failure, if any. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_attempt_failure + end + + # The last attempt's failure, if any. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_attempt_failure=(value) + end + + # The last attempt's failure, if any. + sig { void } + def clear_last_attempt_failure + end + + # The time when the next attempt is scheduled. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def next_attempt_schedule_time + end + + # The time when the next attempt is scheduled. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def next_attempt_schedule_time=(value) + end + + # The time when the next attempt is scheduled. + sig { void } + def clear_next_attempt_schedule_time + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { returns(String) } + def blocked_reason + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { params(value: String).void } + def blocked_reason=(value) + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { void } + def clear_blocked_reason + 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::Callback::V1::CallbackInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Callback::V1::CallbackInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Callback::V1::CallbackInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Callback::V1::CallbackInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/account/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/account/v1/message.rbi new file mode 100644 index 00000000..9b582f91 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/account/v1/message.rbi @@ -0,0 +1,650 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/account/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Account::V1::MetricsSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + accepted_client_ca: T.nilable(String) + ).void + end + def initialize( + accepted_client_ca: "" + ) + end + + # The ca cert(s) in PEM format that clients connecting to the metrics endpoint can use for authentication. +# This must only be one value, but the CA can have a chain. + sig { returns(String) } + def accepted_client_ca + end + + # The ca cert(s) in PEM format that clients connecting to the metrics endpoint can use for authentication. +# This must only be one value, but the CA can have a chain. + sig { params(value: String).void } + def accepted_client_ca=(value) + end + + # The ca cert(s) in PEM format that clients connecting to the metrics endpoint can use for authentication. +# This must only be one value, but the CA can have a chain. + sig { void } + def clear_accepted_client_ca + 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::Cloud::Account::V1::MetricsSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::MetricsSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Account::V1::MetricsSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::MetricsSpec, 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::Cloud::Account::V1::AccountSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + metrics: T.nilable(Temporalio::Api::Cloud::Account::V1::MetricsSpec) + ).void + end + def initialize( + metrics: nil + ) + end + + # The metrics specification for this account. +# If not specified, metrics will not be enabled. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::MetricsSpec)) } + def metrics + end + + # The metrics specification for this account. +# If not specified, metrics will not be enabled. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::MetricsSpec)).void } + def metrics=(value) + end + + # The metrics specification for this account. +# If not specified, metrics will not be enabled. + sig { void } + def clear_metrics + 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::Cloud::Account::V1::AccountSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::AccountSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Account::V1::AccountSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::AccountSpec, 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::Cloud::Account::V1::Metrics + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + uri: T.nilable(String) + ).void + end + def initialize( + uri: "" + ) + end + + # The prometheus metrics endpoint uri. +# This is only populated when the metrics is enabled in the metrics specification. + sig { returns(String) } + def uri + end + + # The prometheus metrics endpoint uri. +# This is only populated when the metrics is enabled in the metrics specification. + sig { params(value: String).void } + def uri=(value) + end + + # The prometheus metrics endpoint uri. +# This is only populated when the metrics is enabled in the metrics specification. + sig { void } + def clear_uri + 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::Cloud::Account::V1::Metrics) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::Metrics).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Account::V1::Metrics) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::Metrics, 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::Cloud::Account::V1::Account + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Account::V1::AccountSpec), + resource_version: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String), + metrics: T.nilable(Temporalio::Api::Cloud::Account::V1::Metrics) + ).void + end + def initialize( + id: "", + spec: nil, + resource_version: "", + state: :RESOURCE_STATE_UNSPECIFIED, + async_operation_id: "", + metrics: nil + ) + end + + # The id of the account. + sig { returns(String) } + def id + end + + # The id of the account. + sig { params(value: String).void } + def id=(value) + end + + # The id of the account. + sig { void } + def clear_id + end + + # The account specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::AccountSpec)) } + def spec + end + + # The account specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::AccountSpec)).void } + def spec=(value) + end + + # The account specification. + sig { void } + def clear_spec + end + + # The current version of the account specification. +# The next update operation will have to include this version. + sig { returns(String) } + def resource_version + end + + # The current version of the account specification. +# The next update operation will have to include this version. + sig { params(value: String).void } + def resource_version=(value) + end + + # The current version of the account specification. +# The next update operation will have to include this version. + sig { void } + def clear_resource_version + end + + # The current state of the account. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the account. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the account. + sig { void } + def clear_state + end + + # The id of the async operation that is updating the account, if any. + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is updating the account, if any. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is updating the account, if any. + sig { void } + def clear_async_operation_id + end + + # Information related to metrics. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::Metrics)) } + def metrics + end + + # Information related to metrics. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::Metrics)).void } + def metrics=(value) + end + + # Information related to metrics. + sig { void } + def clear_metrics + 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::Cloud::Account::V1::Account) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::Account).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Account::V1::Account) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::Account, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# AuditLogSinkSpec is only used by Audit Log +class Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + kinesis_sink: T.nilable(Temporalio::Api::Cloud::Sink::V1::KinesisSpec), + pub_sub_sink: T.nilable(Temporalio::Api::Cloud::Sink::V1::PubSubSpec), + enabled: T.nilable(T::Boolean) + ).void + end + def initialize( + name: "", + kinesis_sink: nil, + pub_sub_sink: nil, + enabled: false + ) + end + + # Name of the sink e.g. "audit_log_01" + sig { returns(String) } + def name + end + + # Name of the sink e.g. "audit_log_01" + sig { params(value: String).void } + def name=(value) + end + + # Name of the sink e.g. "audit_log_01" + sig { void } + def clear_name + end + + # The KinesisSpec when destination_type is Kinesis + sig { returns(T.nilable(Temporalio::Api::Cloud::Sink::V1::KinesisSpec)) } + def kinesis_sink + end + + # The KinesisSpec when destination_type is Kinesis + sig { params(value: T.nilable(Temporalio::Api::Cloud::Sink::V1::KinesisSpec)).void } + def kinesis_sink=(value) + end + + # The KinesisSpec when destination_type is Kinesis + sig { void } + def clear_kinesis_sink + end + + # The PubSubSpec when destination_type is PubSub + sig { returns(T.nilable(Temporalio::Api::Cloud::Sink::V1::PubSubSpec)) } + def pub_sub_sink + end + + # The PubSubSpec when destination_type is PubSub + sig { params(value: T.nilable(Temporalio::Api::Cloud::Sink::V1::PubSubSpec)).void } + def pub_sub_sink=(value) + end + + # The PubSubSpec when destination_type is PubSub + sig { void } + def clear_pub_sub_sink + end + + # Enabled indicates whether the sink is enabled or not. + sig { returns(T::Boolean) } + def enabled + end + + # Enabled indicates whether the sink is enabled or not. + sig { params(value: T::Boolean).void } + def enabled=(value) + end + + # Enabled indicates whether the sink is enabled or not. + sig { void } + def clear_enabled + end + + sig { returns(T.nilable(Symbol)) } + def sink_type + 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::Cloud::Account::V1::AuditLogSinkSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# AuditLogSink is only used by Audit Log +class Temporalio::Api::Cloud::Account::V1::AuditLogSink + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + resource_version: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + spec: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec), + health: T.nilable(T.any(Symbol, String, Integer)), + error_message: T.nilable(String), + last_succeeded_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + name: "", + resource_version: "", + state: :RESOURCE_STATE_UNSPECIFIED, + spec: nil, + health: :HEALTH_UNSPECIFIED, + error_message: "", + last_succeeded_time: nil + ) + end + + # Name of the sink e.g. "audit_log_01" + sig { returns(String) } + def name + end + + # Name of the sink e.g. "audit_log_01" + sig { params(value: String).void } + def name=(value) + end + + # Name of the sink e.g. "audit_log_01" + sig { void } + def clear_name + end + + # The version of the audit log sink resource. + sig { returns(String) } + def resource_version + end + + # The version of the audit log sink resource. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the audit log sink resource. + sig { void } + def clear_resource_version + end + + # The current state of the audit log sink. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the audit log sink. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the audit log sink. + sig { void } + def clear_state + end + + # The specification details of the audit log sink. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec)) } + def spec + end + + # The specification details of the audit log sink. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec)).void } + def spec=(value) + end + + # The specification details of the audit log sink. + sig { void } + def clear_spec + end + + # The health status of the audit log sink. + sig { returns(T.any(Symbol, Integer)) } + def health + end + + # The health status of the audit log sink. + sig { params(value: T.any(Symbol, String, Integer)).void } + def health=(value) + end + + # The health status of the audit log sink. + sig { void } + def clear_health + end + + # An error message describing any issues with the audit log sink, if applicable. + sig { returns(String) } + def error_message + end + + # An error message describing any issues with the audit log sink, if applicable. + sig { params(value: String).void } + def error_message=(value) + end + + # An error message describing any issues with the audit log sink, if applicable. + sig { void } + def clear_error_message + end + + # The last succeeded timestamp for the internal workflow responsible for adding data to the sink. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_succeeded_time + end + + # The last succeeded timestamp for the internal workflow responsible for adding data to the sink. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_succeeded_time=(value) + end + + # The last succeeded timestamp for the internal workflow responsible for adding data to the sink. + sig { void } + def clear_last_succeeded_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::Cloud::Account::V1::AuditLogSink) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::AuditLogSink).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Account::V1::AuditLogSink) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Account::V1::AuditLogSink, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Account::V1::AuditLogSink::Health + self::HEALTH_UNSPECIFIED = T.let(0, Integer) + self::HEALTH_OK = T.let(1, Integer) + self::HEALTH_ERROR_INTERNAL = T.let(2, Integer) + self::HEALTH_ERROR_USER_CONFIGURATION = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/auditlog/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/auditlog/v1/message.rbi new file mode 100644 index 00000000..c0795582 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/auditlog/v1/message.rbi @@ -0,0 +1,318 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/auditlog/v1/message.proto +# typed: strict + +# LogRecord represents an audit log entry from Temporal, structured for easy parsing and analysis. +class Temporalio::Api::Cloud::AuditLog::V1::LogRecord + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + emit_time: T.nilable(Google::Protobuf::Timestamp), + operation: T.nilable(String), + status: T.nilable(String), + version: T.nilable(Integer), + log_id: T.nilable(String), + principal: T.nilable(Temporalio::Api::Cloud::AuditLog::V1::Principal), + raw_details: T.nilable(Google::Protobuf::Struct), + x_forwarded_for: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + emit_time: nil, + operation: "", + status: "", + version: 0, + log_id: "", + principal: nil, + raw_details: nil, + x_forwarded_for: "", + async_operation_id: "" + ) + end + + # Time when the log was emitted. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def emit_time + end + + # Time when the log was emitted. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def emit_time=(value) + end + + # Time when the log was emitted. + sig { void } + def clear_emit_time + end + + # The operation performed. + sig { returns(String) } + def operation + end + + # The operation performed. + sig { params(value: String).void } + def operation=(value) + end + + # The operation performed. + sig { void } + def clear_operation + end + + # The status of the operation. + sig { returns(String) } + def status + end + + # The status of the operation. + sig { params(value: String).void } + def status=(value) + end + + # The status of the operation. + sig { void } + def clear_status + end + + # The internal version of the log message. Can be used in deduplication if needed. + sig { returns(Integer) } + def version + end + + # The internal version of the log message. Can be used in deduplication if needed. + sig { params(value: Integer).void } + def version=(value) + end + + # The internal version of the log message. Can be used in deduplication if needed. + sig { void } + def clear_version + end + + # Unique ID for the log record. + sig { returns(String) } + def log_id + end + + # Unique ID for the log record. + sig { params(value: String).void } + def log_id=(value) + end + + # Unique ID for the log record. + sig { void } + def clear_log_id + end + + # The principal that performed the operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::AuditLog::V1::Principal)) } + def principal + end + + # The principal that performed the operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::AuditLog::V1::Principal)).void } + def principal=(value) + end + + # The principal that performed the operation. + sig { void } + def clear_principal + end + + # The raw details of the operation. + sig { returns(T.nilable(Google::Protobuf::Struct)) } + def raw_details + end + + # The raw details of the operation. + sig { params(value: T.nilable(Google::Protobuf::Struct)).void } + def raw_details=(value) + end + + # The raw details of the operation. + sig { void } + def clear_raw_details + end + + # The originating IP address of the request. + sig { returns(String) } + def x_forwarded_for + end + + # The originating IP address of the request. + sig { params(value: String).void } + def x_forwarded_for=(value) + end + + # The originating IP address of the request. + sig { void } + def clear_x_forwarded_for + end + + # The ID of the async operation. + sig { returns(String) } + def async_operation_id + end + + # The ID of the async operation. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID of the async operation. + sig { void } + def clear_async_operation_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::Cloud::AuditLog::V1::LogRecord) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::AuditLog::V1::LogRecord).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::AuditLog::V1::LogRecord) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::AuditLog::V1::LogRecord, 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::Cloud::AuditLog::V1::Principal + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(String), + id: T.nilable(String), + name: T.nilable(String), + api_key_id: T.nilable(String) + ).void + end + def initialize( + type: "", + id: "", + name: "", + api_key_id: "" + ) + end + + # The type of the principal. +# Possible type values: user, serviceaccount. + sig { returns(String) } + def type + end + + # The type of the principal. +# Possible type values: user, serviceaccount. + sig { params(value: String).void } + def type=(value) + end + + # The type of the principal. +# Possible type values: user, serviceaccount. + sig { void } + def clear_type + end + + # The id of the principal. + sig { returns(String) } + def id + end + + # The id of the principal. + sig { params(value: String).void } + def id=(value) + end + + # The id of the principal. + sig { void } + def clear_id + end + + # The name of the principal. + sig { returns(String) } + def name + end + + # The name of the principal. + sig { params(value: String).void } + def name=(value) + end + + # The name of the principal. + sig { void } + def clear_name + end + + # The api key id of the principal if provided. + sig { returns(String) } + def api_key_id + end + + # The api key id of the principal if provided. + sig { params(value: String).void } + def api_key_id=(value) + end + + # The api key id of the principal if provided. + sig { void } + def clear_api_key_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::Cloud::AuditLog::V1::Principal) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::AuditLog::V1::Principal).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::AuditLog::V1::Principal) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::AuditLog::V1::Principal, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/billing/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/billing/v1/message.rbi new file mode 100644 index 00000000..20242ad0 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/billing/v1/message.rbi @@ -0,0 +1,438 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/billing/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Billing::V1::BillingReportSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_time_inclusive: T.nilable(Google::Protobuf::Timestamp), + end_time_exclusive: T.nilable(Google::Protobuf::Timestamp), + download_url_expiration_duration: T.nilable(Google::Protobuf::Duration), + description: T.nilable(String) + ).void + end + def initialize( + start_time_inclusive: nil, + end_time_exclusive: nil, + download_url_expiration_duration: nil, + description: "" + ) + end + + # The start time of the billing report (in UTC). + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time_inclusive + end + + # The start time of the billing report (in UTC). + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time_inclusive=(value) + end + + # The start time of the billing report (in UTC). + sig { void } + def clear_start_time_inclusive + end + + # The end time of the billing report (in UTC). + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def end_time_exclusive + end + + # The end time of the billing report (in UTC). + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def end_time_exclusive=(value) + end + + # The end time of the billing report (in UTC). + sig { void } + def clear_end_time_exclusive + end + + # The duration after which the download url will expire. +# Optional, default is 5 minutes and maximum is 1 hour. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def download_url_expiration_duration + end + + # The duration after which the download url will expire. +# Optional, default is 5 minutes and maximum is 1 hour. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def download_url_expiration_duration=(value) + end + + # The duration after which the download url will expire. +# Optional, default is 5 minutes and maximum is 1 hour. + sig { void } + def clear_download_url_expiration_duration + end + + # The description for the billing report. +# Optional, default is empty. + sig { returns(String) } + def description + end + + # The description for the billing report. +# Optional, default is empty. + sig { params(value: String).void } + def description=(value) + end + + # The description for the billing report. +# Optional, default is empty. + sig { void } + def clear_description + 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::Cloud::Billing::V1::BillingReportSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Billing::V1::BillingReportSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Billing::V1::BillingReportSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Billing::V1::BillingReportSpec, 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::Cloud::Billing::V1::BillingReport + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + spec: T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReportSpec), + download_info: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReport::Download)]), + requested_time: T.nilable(Google::Protobuf::Timestamp), + generated_time: T.nilable(Google::Protobuf::Timestamp), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + id: "", + state: :BILLING_REPORT_STATE_UNSPECIFIED, + spec: nil, + download_info: [], + requested_time: nil, + generated_time: nil, + async_operation_id: "" + ) + end + + # The id of the billing report. + sig { returns(String) } + def id + end + + # The id of the billing report. + sig { params(value: String).void } + def id=(value) + end + + # The id of the billing report. + sig { void } + def clear_id + end + + # The current state of the billing report. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the billing report. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the billing report. + sig { void } + def clear_state + end + + # The spec used to generate this billing report. + sig { returns(T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReportSpec)) } + def spec + end + + # The spec used to generate this billing report. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReportSpec)).void } + def spec=(value) + end + + # The spec used to generate this billing report. + sig { void } + def clear_spec + end + + # The download information for the billing report. +# For future-proofness this is repeated as we may return multiple files (e.g. csv+meta/json, split by size/date, etc.) + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReport::Download)]) } + def download_info + end + + # The download information for the billing report. +# For future-proofness this is repeated as we may return multiple files (e.g. csv+meta/json, split by size/date, etc.) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def download_info=(value) + end + + # The download information for the billing report. +# For future-proofness this is repeated as we may return multiple files (e.g. csv+meta/json, split by size/date, etc.) + sig { void } + def clear_download_info + end + + # The date and time when the billing report was requested. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def requested_time + end + + # The date and time when the billing report was requested. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def requested_time=(value) + end + + # The date and time when the billing report was requested. + sig { void } + def clear_requested_time + end + + # The date and time when the billing report generation completed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def generated_time + end + + # The date and time when the billing report generation completed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def generated_time=(value) + end + + # The date and time when the billing report generation completed. + sig { void } + def clear_generated_time + end + + # The async operation id associated with the billing report generation. + sig { returns(String) } + def async_operation_id + end + + # The async operation id associated with the billing report generation. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The async operation id associated with the billing report generation. + sig { void } + def clear_async_operation_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::Cloud::Billing::V1::BillingReport) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Billing::V1::BillingReport).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Billing::V1::BillingReport) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Billing::V1::BillingReport, 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::Cloud::Billing::V1::BillingReport::Download + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + url: T.nilable(String), + url_expiration_time: T.nilable(Google::Protobuf::Timestamp), + file_format: T.nilable(T.any(Symbol, String, Integer)), + file_size_bytes: T.nilable(Integer) + ).void + end + def initialize( + url: "", + url_expiration_time: nil, + file_format: :FILE_FORMAT_UNSPECIFIED, + file_size_bytes: 0 + ) + end + + # The download url. + sig { returns(String) } + def url + end + + # The download url. + sig { params(value: String).void } + def url=(value) + end + + # The download url. + sig { void } + def clear_url + end + + # The time when the download url will expire. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def url_expiration_time + end + + # The time when the download url will expire. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def url_expiration_time=(value) + end + + # The time when the download url will expire. + sig { void } + def clear_url_expiration_time + end + + # The file format of the billing report + sig { returns(T.any(Symbol, Integer)) } + def file_format + end + + # The file format of the billing report + sig { params(value: T.any(Symbol, String, Integer)).void } + def file_format=(value) + end + + # The file format of the billing report + sig { void } + def clear_file_format + end + + # The size of the file in bytes. Useful for pre-allocating space, progress indicators, etc. + sig { returns(Integer) } + def file_size_bytes + end + + # The size of the file in bytes. Useful for pre-allocating space, progress indicators, etc. + sig { params(value: Integer).void } + def file_size_bytes=(value) + end + + # The size of the file in bytes. Useful for pre-allocating space, progress indicators, etc. + sig { void } + def clear_file_size_bytes + 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::Cloud::Billing::V1::BillingReport::Download) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Billing::V1::BillingReport::Download).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Billing::V1::BillingReport::Download) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Billing::V1::BillingReport::Download, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Billing::V1::BillingReport::BillingReportState + self::BILLING_REPORT_STATE_UNSPECIFIED = T.let(0, Integer) + self::BILLING_REPORT_STATE_IN_PROGRESS = T.let(1, Integer) + self::BILLING_REPORT_STATE_GENERATED = T.let(2, Integer) + self::BILLING_REPORT_STATE_FAILED = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Billing::V1::BillingReport::Download::FileFormat + self::FILE_FORMAT_UNSPECIFIED = T.let(0, Integer) + self::FILE_FORMAT_CSV = T.let(1, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/cloudservice.rbi b/temporalio/rbi/temporalio/api/cloud/cloudservice.rbi new file mode 100644 index 00000000..159d5f65 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/cloudservice.rbi @@ -0,0 +1,5 @@ +# typed: true + +# Generated code. DO NOT EDIT! + +module Temporalio::Api::Cloud::CloudService; end diff --git a/temporalio/rbi/temporalio/api/cloud/cloudservice/v1/request_response.rbi b/temporalio/rbi/temporalio/api/cloud/cloudservice/v1/request_response.rbi new file mode 100644 index 00000000..be86f6f1 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/cloudservice/v1/request_response.rbi @@ -0,0 +1,11129 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/cloudservice/v1/request_response.proto +# typed: strict + +class Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::CloudService::V1::GetCurrentIdentityRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityRequest, 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::Cloud::CloudService::V1::GetCurrentIdentityResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + user: T.nilable(Temporalio::Api::Cloud::Identity::V1::User), + service_account: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccount), + principal_api_key: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKey) + ).void + end + def initialize( + user: nil, + service_account: nil, + principal_api_key: nil + ) + end + + # The user is a regular user + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::User)) } + def user + end + + # The user is a regular user + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::User)).void } + def user=(value) + end + + # The user is a regular user + sig { void } + def clear_user + end + + # The user is a service account + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccount)) } + def service_account + end + + # The user is a service account + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccount)).void } + def service_account=(value) + end + + # The user is a service account + sig { void } + def clear_service_account + end + + # The API key info used to authenticate the request, if any + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKey)) } + def principal_api_key + end + + # The API key info used to authenticate the request, if any + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKey)).void } + def principal_api_key=(value) + end + + # The API key info used to authenticate the request, if any + sig { void } + def clear_principal_api_key + end + + sig { returns(T.nilable(Symbol)) } + def principal + 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::Cloud::CloudService::V1::GetCurrentIdentityResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityResponse, 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::Cloud::CloudService::V1::GetUsersRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String), + email: T.nilable(String), + namespace: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + page_token: "", + email: "", + namespace: "" + ) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + end + + # Filter users by email address - optional. + sig { returns(String) } + def email + end + + # Filter users by email address - optional. + sig { params(value: String).void } + def email=(value) + end + + # Filter users by email address - optional. + sig { void } + def clear_email + end + + # Filter users by the namespace they have access to - optional. + sig { returns(String) } + def namespace + end + + # Filter users by the namespace they have access to - optional. + sig { params(value: String).void } + def namespace=(value) + end + + # Filter users by the namespace they have access to - optional. + sig { void } + def clear_namespace + 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::Cloud::CloudService::V1::GetUsersRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUsersRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUsersRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUsersRequest, 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::Cloud::CloudService::V1::GetUsersResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + users: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::User)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + users: [], + next_page_token: "" + ) + end + + # The list of users in ascending ids order + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::User)]) } + def users + end + + # The list of users in ascending ids order + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def users=(value) + end + + # The list of users in ascending ids order + sig { void } + def clear_users + end + + # The next page's token + sig { returns(String) } + def next_page_token + end + + # The next page's token + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page's token + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetUsersResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUsersResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUsersResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUsersResponse, 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::Cloud::CloudService::V1::GetUserRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + user_id: T.nilable(String) + ).void + end + def initialize( + user_id: "" + ) + end + + # The id of the user to get + sig { returns(String) } + def user_id + end + + # The id of the user to get + sig { params(value: String).void } + def user_id=(value) + end + + # The id of the user to get + sig { void } + def clear_user_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::Cloud::CloudService::V1::GetUserRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserRequest, 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::Cloud::CloudService::V1::GetUserResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + user: T.nilable(Temporalio::Api::Cloud::Identity::V1::User) + ).void + end + def initialize( + user: nil + ) + end + + # The user + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::User)) } + def user + end + + # The user + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::User)).void } + def user=(value) + end + + # The user + sig { void } + def clear_user + 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::Cloud::CloudService::V1::GetUserResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserResponse, 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::Cloud::CloudService::V1::CreateUserRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + async_operation_id: "" + ) + end + + # The spec for the user to invite + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec)) } + def spec + end + + # The spec for the user to invite + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec)).void } + def spec=(value) + end + + # The spec for the user to invite + sig { void } + def clear_spec + end + + # The id to use for this async operation - optional + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateUserRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateUserRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateUserRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateUserRequest, 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::Cloud::CloudService::V1::CreateUserResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + user_id: T.nilable(String), + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + user_id: "", + async_operation: nil + ) + end + + # The id of the user that was invited + sig { returns(String) } + def user_id + end + + # The id of the user that was invited + sig { params(value: String).void } + def user_id=(value) + end + + # The id of the user that was invited + sig { void } + def clear_user_id + end + + # The async operation + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateUserResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateUserResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateUserResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateUserResponse, 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::Cloud::CloudService::V1::UpdateUserRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + user_id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + user_id: "", + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The id of the user to update + sig { returns(String) } + def user_id + end + + # The id of the user to update + sig { params(value: String).void } + def user_id=(value) + end + + # The id of the user to update + sig { void } + def clear_user_id + end + + # The new user specification + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec)) } + def spec + end + + # The new user specification + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec)).void } + def spec=(value) + end + + # The new user specification + sig { void } + def clear_spec + end + + # The version of the user for which this update is intended for +# The latest version can be found in the GetUser operation response + sig { returns(String) } + def resource_version + end + + # The version of the user for which this update is intended for +# The latest version can be found in the GetUser operation response + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the user for which this update is intended for +# The latest version can be found in the GetUser operation response + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateUserRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateUserRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateUserRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateUserRequest, 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::Cloud::CloudService::V1::UpdateUserResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateUserResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateUserResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateUserResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateUserResponse, 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::Cloud::CloudService::V1::DeleteUserRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + user_id: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + user_id: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The id of the user to delete + sig { returns(String) } + def user_id + end + + # The id of the user to delete + sig { params(value: String).void } + def user_id=(value) + end + + # The id of the user to delete + sig { void } + def clear_user_id + end + + # The version of the user for which this delete is intended for +# The latest version can be found in the GetUser operation response + sig { returns(String) } + def resource_version + end + + # The version of the user for which this delete is intended for +# The latest version can be found in the GetUser operation response + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the user for which this delete is intended for +# The latest version can be found in the GetUser operation response + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteUserRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteUserRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteUserRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteUserRequest, 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::Cloud::CloudService::V1::DeleteUserResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteUserResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteUserResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteUserResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteUserResponse, 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::Cloud::CloudService::V1::SetUserNamespaceAccessRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + user_id: T.nilable(String), + access: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + user_id: "", + access: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to set permissions for + sig { returns(String) } + def namespace + end + + # The namespace to set permissions for + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to set permissions for + sig { void } + def clear_namespace + end + + # The id of the user to set permissions for + sig { returns(String) } + def user_id + end + + # The id of the user to set permissions for + sig { params(value: String).void } + def user_id=(value) + end + + # The id of the user to set permissions for + sig { void } + def clear_user_id + end + + # The namespace access to assign the user + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)) } + def access + end + + # The namespace access to assign the user + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)).void } + def access=(value) + end + + # The namespace access to assign the user + sig { void } + def clear_access + end + + # The version of the user for which this update is intended for +# The latest version can be found in the GetUser operation response + sig { returns(String) } + def resource_version + end + + # The version of the user for which this update is intended for +# The latest version can be found in the GetUser operation response + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the user for which this update is intended for +# The latest version can be found in the GetUser operation response + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::SetUserNamespaceAccessRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetUserNamespaceAccessRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::SetUserNamespaceAccessRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetUserNamespaceAccessRequest, 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::Cloud::CloudService::V1::SetUserNamespaceAccessResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::SetUserNamespaceAccessResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetUserNamespaceAccessResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::SetUserNamespaceAccessResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetUserNamespaceAccessResponse, 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::Cloud::CloudService::V1::GetAsyncOperationRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation_id: T.nilable(String) + ).void + end + def initialize( + async_operation_id: "" + ) + end + + # The id of the async operation to get + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation to get + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation to get + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::GetAsyncOperationRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAsyncOperationRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAsyncOperationRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAsyncOperationRequest, 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::Cloud::CloudService::V1::GetAsyncOperationResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::GetAsyncOperationResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAsyncOperationResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAsyncOperationResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAsyncOperationResponse, 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::Cloud::CloudService::V1::CreateNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec), + async_operation_id: T.nilable(String), + tags: T.nilable(T::Hash[String, String]) + ).void + end + def initialize( + spec: nil, + async_operation_id: "", + tags: ::Google::Protobuf::Map.new(:string, :string) + ) + end + + # The namespace specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec)) } + def spec + end + + # The namespace specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec)).void } + def spec=(value) + end + + # The namespace specification. + sig { void } + def clear_spec + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_id + end + + # The tags to add to the namespace. +# Note: This field can be set by global admins or account owners only. + sig { returns(T::Hash[String, String]) } + def tags + end + + # The tags to add to the namespace. +# Note: This field can be set by global admins or account owners only. + sig { params(value: ::Google::Protobuf::Map).void } + def tags=(value) + end + + # The tags to add to the namespace. +# Note: This field can be set by global admins or account owners only. + sig { void } + def clear_tags + 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::Cloud::CloudService::V1::CreateNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceRequest, 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::Cloud::CloudService::V1::CreateNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + namespace: "", + async_operation: nil + ) + end + + # The namespace that was created. + sig { returns(String) } + def namespace + end + + # The namespace that was created. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace that was created. + sig { void } + def clear_namespace + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceResponse, 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::Cloud::CloudService::V1::GetNamespacesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String), + name: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + page_token: "", + name: "" + ) + end + + # The requested size of the page to retrieve. +# Cannot exceed 1000. +# Optional, defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve. +# Cannot exceed 1000. +# Optional, defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve. +# Cannot exceed 1000. +# Optional, defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response. +# Optional, defaults to empty. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response. +# Optional, defaults to empty. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response. +# Optional, defaults to empty. + sig { void } + def clear_page_token + end + + # Filter namespaces by their name. +# Optional, defaults to empty. + sig { returns(String) } + def name + end + + # Filter namespaces by their name. +# Optional, defaults to empty. + sig { params(value: String).void } + def name=(value) + end + + # Filter namespaces by their name. +# Optional, defaults to empty. + sig { void } + def clear_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::Cloud::CloudService::V1::GetNamespacesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespacesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespacesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespacesRequest, 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::Cloud::CloudService::V1::GetNamespacesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespaces: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Namespace::V1::Namespace)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + namespaces: [], + next_page_token: "" + ) + end + + # The list of namespaces in ascending name order. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Namespace::V1::Namespace)]) } + def namespaces + end + + # The list of namespaces in ascending name order. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def namespaces=(value) + end + + # The list of namespaces in ascending name order. + sig { void } + def clear_namespaces + end + + # The next page's token. + sig { returns(String) } + def next_page_token + end + + # The next page's token. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page's token. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetNamespacesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespacesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespacesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespacesResponse, 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::Cloud::CloudService::V1::GetNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String) + ).void + end + def initialize( + namespace: "" + ) + end + + # The namespace to get. + sig { returns(String) } + def namespace + end + + # The namespace to get. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to get. + sig { void } + def clear_namespace + 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::Cloud::CloudService::V1::GetNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceRequest, 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::Cloud::CloudService::V1::GetNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Namespace) + ).void + end + def initialize( + namespace: nil + ) + end + + # The namespace. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::Namespace)) } + def namespace + end + + # The namespace. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Namespace)).void } + def namespace=(value) + end + + # The namespace. + sig { void } + def clear_namespace + 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::Cloud::CloudService::V1::GetNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceResponse, 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::Cloud::CloudService::V1::UpdateNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to update. + sig { returns(String) } + def namespace + end + + # The namespace to update. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to update. + sig { void } + def clear_namespace + end + + # The new namespace specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec)) } + def spec + end + + # The new namespace specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec)).void } + def spec=(value) + end + + # The new namespace specification. + sig { void } + def clear_spec + end + + # The version of the namespace for which this update is intended for. +# The latest version can be found in the namespace status. + sig { returns(String) } + def resource_version + end + + # The version of the namespace for which this update is intended for. +# The latest version can be found in the namespace status. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the namespace for which this update is intended for. +# The latest version can be found in the namespace status. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceRequest, 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::Cloud::CloudService::V1::UpdateNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceResponse, 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::Cloud::CloudService::V1::RenameCustomSearchAttributeRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + existing_custom_search_attribute_name: T.nilable(String), + new_custom_search_attribute_name: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + existing_custom_search_attribute_name: "", + new_custom_search_attribute_name: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to rename the custom search attribute for. + sig { returns(String) } + def namespace + end + + # The namespace to rename the custom search attribute for. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to rename the custom search attribute for. + sig { void } + def clear_namespace + end + + # The existing name of the custom search attribute to be renamed. + sig { returns(String) } + def existing_custom_search_attribute_name + end + + # The existing name of the custom search attribute to be renamed. + sig { params(value: String).void } + def existing_custom_search_attribute_name=(value) + end + + # The existing name of the custom search attribute to be renamed. + sig { void } + def clear_existing_custom_search_attribute_name + end + + # The new name of the custom search attribute. + sig { returns(String) } + def new_custom_search_attribute_name + end + + # The new name of the custom search attribute. + sig { params(value: String).void } + def new_custom_search_attribute_name=(value) + end + + # The new name of the custom search attribute. + sig { void } + def clear_new_custom_search_attribute_name + end + + # The version of the namespace for which this update is intended for. +# The latest version can be found in the namespace status. + sig { returns(String) } + def resource_version + end + + # The version of the namespace for which this update is intended for. +# The latest version can be found in the namespace status. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the namespace for which this update is intended for. +# The latest version can be found in the namespace status. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::RenameCustomSearchAttributeRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::RenameCustomSearchAttributeRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::RenameCustomSearchAttributeRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::RenameCustomSearchAttributeRequest, 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::Cloud::CloudService::V1::RenameCustomSearchAttributeResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::RenameCustomSearchAttributeResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::RenameCustomSearchAttributeResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::RenameCustomSearchAttributeResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::RenameCustomSearchAttributeResponse, 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::Cloud::CloudService::V1::DeleteNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to delete. + sig { returns(String) } + def namespace + end + + # The namespace to delete. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to delete. + sig { void } + def clear_namespace + end + + # The version of the namespace for which this delete is intended for. +# The latest version can be found in the namespace status. + sig { returns(String) } + def resource_version + end + + # The version of the namespace for which this delete is intended for. +# The latest version can be found in the namespace status. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the namespace for which this delete is intended for. +# The latest version can be found in the namespace status. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRequest, 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::Cloud::CloudService::V1::DeleteNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceResponse, 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::Cloud::CloudService::V1::FailoverNamespaceRegionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + region: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + region: "", + async_operation_id: "" + ) + end + + # The namespace to failover. + sig { returns(String) } + def namespace + end + + # The namespace to failover. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to failover. + sig { void } + def clear_namespace + end + + # The id of the region to failover to. +# Must be a region that the namespace is currently available in. + sig { returns(String) } + def region + end + + # The id of the region to failover to. +# Must be a region that the namespace is currently available in. + sig { params(value: String).void } + def region=(value) + end + + # The id of the region to failover to. +# Must be a region that the namespace is currently available in. + sig { void } + def clear_region + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::FailoverNamespaceRegionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::FailoverNamespaceRegionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::FailoverNamespaceRegionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::FailoverNamespaceRegionRequest, 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::Cloud::CloudService::V1::FailoverNamespaceRegionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::FailoverNamespaceRegionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::FailoverNamespaceRegionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::FailoverNamespaceRegionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::FailoverNamespaceRegionResponse, 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::Cloud::CloudService::V1::AddNamespaceRegionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + region: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + region: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to add the region to. + sig { returns(String) } + def namespace + end + + # The namespace to add the region to. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to add the region to. + sig { void } + def clear_namespace + end + + # The id of the standby region to add to the namespace. +# The GetRegions API can be used to get the list of valid region ids. +# Example: "aws-us-west-2". + sig { returns(String) } + def region + end + + # The id of the standby region to add to the namespace. +# The GetRegions API can be used to get the list of valid region ids. +# Example: "aws-us-west-2". + sig { params(value: String).void } + def region=(value) + end + + # The id of the standby region to add to the namespace. +# The GetRegions API can be used to get the list of valid region ids. +# Example: "aws-us-west-2". + sig { void } + def clear_region + end + + # The version of the namespace for which this add region operation is intended for. +# The latest version can be found in the GetNamespace operation response. + sig { returns(String) } + def resource_version + end + + # The version of the namespace for which this add region operation is intended for. +# The latest version can be found in the GetNamespace operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the namespace for which this add region operation is intended for. +# The latest version can be found in the GetNamespace operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::AddNamespaceRegionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::AddNamespaceRegionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::AddNamespaceRegionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::AddNamespaceRegionRequest, 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::Cloud::CloudService::V1::AddNamespaceRegionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::AddNamespaceRegionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::AddNamespaceRegionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::AddNamespaceRegionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::AddNamespaceRegionResponse, 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::Cloud::CloudService::V1::DeleteNamespaceRegionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + region: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + region: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to delete a region. + sig { returns(String) } + def namespace + end + + # The namespace to delete a region. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to delete a region. + sig { void } + def clear_namespace + end + + # The id of the standby region to be deleted. +# The GetRegions API can be used to get the list of valid region ids. +# Example: "aws-us-west-2". + sig { returns(String) } + def region + end + + # The id of the standby region to be deleted. +# The GetRegions API can be used to get the list of valid region ids. +# Example: "aws-us-west-2". + sig { params(value: String).void } + def region=(value) + end + + # The id of the standby region to be deleted. +# The GetRegions API can be used to get the list of valid region ids. +# Example: "aws-us-west-2". + sig { void } + def clear_region + end + + # The version of the namespace for which this delete region operation is intended for. +# The latest version can be found in the GetNamespace operation response. + sig { returns(String) } + def resource_version + end + + # The version of the namespace for which this delete region operation is intended for. +# The latest version can be found in the GetNamespace operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the namespace for which this delete region operation is intended for. +# The latest version can be found in the GetNamespace operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteNamespaceRegionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionRequest, 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::Cloud::CloudService::V1::DeleteNamespaceRegionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteNamespaceRegionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionResponse, 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::Cloud::CloudService::V1::GetRegionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::CloudService::V1::GetRegionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetRegionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetRegionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetRegionsRequest, 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::Cloud::CloudService::V1::GetRegionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + regions: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Region::V1::Region)]) + ).void + end + def initialize( + regions: [] + ) + end + + # The temporal cloud regions. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Region::V1::Region)]) } + def regions + end + + # The temporal cloud regions. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def regions=(value) + end + + # The temporal cloud regions. + sig { void } + def clear_regions + 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::Cloud::CloudService::V1::GetRegionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetRegionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetRegionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetRegionsResponse, 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::Cloud::CloudService::V1::GetRegionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + region: T.nilable(String) + ).void + end + def initialize( + region: "" + ) + end + + # The id of the region to get. + sig { returns(String) } + def region + end + + # The id of the region to get. + sig { params(value: String).void } + def region=(value) + end + + # The id of the region to get. + sig { void } + def clear_region + 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::Cloud::CloudService::V1::GetRegionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetRegionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetRegionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetRegionRequest, 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::Cloud::CloudService::V1::GetRegionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + region: T.nilable(Temporalio::Api::Cloud::Region::V1::Region) + ).void + end + def initialize( + region: nil + ) + end + + # The temporal cloud region. + sig { returns(T.nilable(Temporalio::Api::Cloud::Region::V1::Region)) } + def region + end + + # The temporal cloud region. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Region::V1::Region)).void } + def region=(value) + end + + # The temporal cloud region. + sig { void } + def clear_region + 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::Cloud::CloudService::V1::GetRegionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetRegionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetRegionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetRegionResponse, 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::Cloud::CloudService::V1::GetApiKeysRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String), + owner_id: T.nilable(String), + owner_type_deprecated: T.nilable(String), + owner_type: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + page_size: 0, + page_token: "", + owner_id: "", + owner_type_deprecated: "", + owner_type: :OWNER_TYPE_UNSPECIFIED + ) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + end + + # Filter api keys by owner id - optional. + sig { returns(String) } + def owner_id + end + + # Filter api keys by owner id - optional. + sig { params(value: String).void } + def owner_id=(value) + end + + # Filter api keys by owner id - optional. + sig { void } + def clear_owner_id + end + + # Filter api keys by owner type - optional. +# Possible values: user, service-account +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def owner_type_deprecated + end + + # Filter api keys by owner type - optional. +# Possible values: user, service-account +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def owner_type_deprecated=(value) + end + + # Filter api keys by owner type - optional. +# Possible values: user, service-account +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_owner_type_deprecated + end + + # Filter api keys by owner type - optional. +# temporal:enums:replaces=owner_type_deprecated + sig { returns(T.any(Symbol, Integer)) } + def owner_type + end + + # Filter api keys by owner type - optional. +# temporal:enums:replaces=owner_type_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def owner_type=(value) + end + + # Filter api keys by owner type - optional. +# temporal:enums:replaces=owner_type_deprecated + sig { void } + def clear_owner_type + 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::Cloud::CloudService::V1::GetApiKeysRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetApiKeysRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetApiKeysRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetApiKeysRequest, 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::Cloud::CloudService::V1::GetApiKeysResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + api_keys: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKey)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + api_keys: [], + next_page_token: "" + ) + end + + # The list of api keys in ascending id order. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKey)]) } + def api_keys + end + + # The list of api keys in ascending id order. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def api_keys=(value) + end + + # The list of api keys in ascending id order. + sig { void } + def clear_api_keys + end + + # The next page's token. + sig { returns(String) } + def next_page_token + end + + # The next page's token. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page's token. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetApiKeysResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetApiKeysResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetApiKeysResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetApiKeysResponse, 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::Cloud::CloudService::V1::GetApiKeyRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + key_id: T.nilable(String) + ).void + end + def initialize( + key_id: "" + ) + end + + # The id of the api key to get. + sig { returns(String) } + def key_id + end + + # The id of the api key to get. + sig { params(value: String).void } + def key_id=(value) + end + + # The id of the api key to get. + sig { void } + def clear_key_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::Cloud::CloudService::V1::GetApiKeyRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetApiKeyRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetApiKeyRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetApiKeyRequest, 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::Cloud::CloudService::V1::GetApiKeyResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + api_key: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKey) + ).void + end + def initialize( + api_key: nil + ) + end + + # The api key. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKey)) } + def api_key + end + + # The api key. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKey)).void } + def api_key=(value) + end + + # The api key. + sig { void } + def clear_api_key + 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::Cloud::CloudService::V1::GetApiKeyResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetApiKeyResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetApiKeyResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetApiKeyResponse, 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::Cloud::CloudService::V1::CreateApiKeyRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + async_operation_id: "" + ) + end + + # The spec for the api key to create. +# Create api key only supports service-account owner type for now. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec)) } + def spec + end + + # The spec for the api key to create. +# Create api key only supports service-account owner type for now. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec)).void } + def spec=(value) + end + + # The spec for the api key to create. +# Create api key only supports service-account owner type for now. + sig { void } + def clear_spec + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateApiKeyRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateApiKeyRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateApiKeyRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateApiKeyRequest, 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::Cloud::CloudService::V1::CreateApiKeyResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + key_id: T.nilable(String), + token: T.nilable(String), + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + key_id: "", + token: "", + async_operation: nil + ) + end + + # The id of the api key created. + sig { returns(String) } + def key_id + end + + # The id of the api key created. + sig { params(value: String).void } + def key_id=(value) + end + + # The id of the api key created. + sig { void } + def clear_key_id + end + + # The token of the api key created. +# This is a secret and should be stored securely. +# It will not be retrievable after this response. + sig { returns(String) } + def token + end + + # The token of the api key created. +# This is a secret and should be stored securely. +# It will not be retrievable after this response. + sig { params(value: String).void } + def token=(value) + end + + # The token of the api key created. +# This is a secret and should be stored securely. +# It will not be retrievable after this response. + sig { void } + def clear_token + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateApiKeyResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateApiKeyResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateApiKeyResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateApiKeyResponse, 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::Cloud::CloudService::V1::UpdateApiKeyRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + key_id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + key_id: "", + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The id of the api key to update. + sig { returns(String) } + def key_id + end + + # The id of the api key to update. + sig { params(value: String).void } + def key_id=(value) + end + + # The id of the api key to update. + sig { void } + def clear_key_id + end + + # The new api key specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec)) } + def spec + end + + # The new api key specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec)).void } + def spec=(value) + end + + # The new api key specification. + sig { void } + def clear_spec + end + + # The version of the api key for which this update is intended for. +# The latest version can be found in the GetApiKey operation response. + sig { returns(String) } + def resource_version + end + + # The version of the api key for which this update is intended for. +# The latest version can be found in the GetApiKey operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the api key for which this update is intended for. +# The latest version can be found in the GetApiKey operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateApiKeyRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateApiKeyRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateApiKeyRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateApiKeyRequest, 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::Cloud::CloudService::V1::UpdateApiKeyResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateApiKeyResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateApiKeyResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateApiKeyResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateApiKeyResponse, 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::Cloud::CloudService::V1::DeleteApiKeyRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + key_id: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + key_id: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The id of the api key to delete. + sig { returns(String) } + def key_id + end + + # The id of the api key to delete. + sig { params(value: String).void } + def key_id=(value) + end + + # The id of the api key to delete. + sig { void } + def clear_key_id + end + + # The version of the api key for which this delete is intended for. +# The latest version can be found in the GetApiKey operation response. + sig { returns(String) } + def resource_version + end + + # The version of the api key for which this delete is intended for. +# The latest version can be found in the GetApiKey operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the api key for which this delete is intended for. +# The latest version can be found in the GetApiKey operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteApiKeyRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteApiKeyRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteApiKeyRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteApiKeyRequest, 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::Cloud::CloudService::V1::DeleteApiKeyResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteApiKeyResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteApiKeyResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteApiKeyResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteApiKeyResponse, 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::Cloud::CloudService::V1::GetNexusEndpointsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String), + target_namespace_id: T.nilable(String), + target_task_queue: T.nilable(String), + name: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + page_token: "", + target_namespace_id: "", + target_task_queue: "", + name: "" + ) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + end + + # optional, treated as an AND if specified + sig { returns(String) } + def target_namespace_id + end + + # optional, treated as an AND if specified + sig { params(value: String).void } + def target_namespace_id=(value) + end + + # optional, treated as an AND if specified + sig { void } + def clear_target_namespace_id + end + + # optional, treated as an AND if specified + sig { returns(String) } + def target_task_queue + end + + # optional, treated as an AND if specified + sig { params(value: String).void } + def target_task_queue=(value) + end + + # optional, treated as an AND if specified + sig { void } + def clear_target_task_queue + end + + # Filter endpoints by their name - optional, treated as an AND if specified. Specifying this will result in zero or one results. + sig { returns(String) } + def name + end + + # Filter endpoints by their name - optional, treated as an AND if specified. Specifying this will result in zero or one results. + sig { params(value: String).void } + def name=(value) + end + + # Filter endpoints by their name - optional, treated as an AND if specified. Specifying this will result in zero or one results. + sig { void } + def clear_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::Cloud::CloudService::V1::GetNexusEndpointsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointsRequest, 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::Cloud::CloudService::V1::GetNexusEndpointsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoints: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Nexus::V1::Endpoint)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + endpoints: [], + next_page_token: "" + ) + end + + # The list of endpoints in ascending id order. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Nexus::V1::Endpoint)]) } + def endpoints + end + + # The list of endpoints in ascending id order. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def endpoints=(value) + end + + # The list of endpoints in ascending id order. + sig { void } + def clear_endpoints + end + + # The next page's token. + sig { returns(String) } + def next_page_token + end + + # The next page's token. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page's token. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetNexusEndpointsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointsResponse, 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::Cloud::CloudService::V1::GetNexusEndpointRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint_id: T.nilable(String) + ).void + end + def initialize( + endpoint_id: "" + ) + end + + # The id of the nexus endpoint to get. + sig { returns(String) } + def endpoint_id + end + + # The id of the nexus endpoint to get. + sig { params(value: String).void } + def endpoint_id=(value) + end + + # The id of the nexus endpoint to get. + sig { void } + def clear_endpoint_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::Cloud::CloudService::V1::GetNexusEndpointRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointRequest, 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::Cloud::CloudService::V1::GetNexusEndpointResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint: T.nilable(Temporalio::Api::Cloud::Nexus::V1::Endpoint) + ).void + end + def initialize( + endpoint: nil + ) + end + + # The nexus endpoint. + sig { returns(T.nilable(Temporalio::Api::Cloud::Nexus::V1::Endpoint)) } + def endpoint + end + + # The nexus endpoint. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Nexus::V1::Endpoint)).void } + def endpoint=(value) + end + + # The nexus endpoint. + sig { void } + def clear_endpoint + 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::Cloud::CloudService::V1::GetNexusEndpointResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointResponse, 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::Cloud::CloudService::V1::CreateNexusEndpointRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + async_operation_id: "" + ) + end + + # The spec for the nexus endpoint. + sig { returns(T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec)) } + def spec + end + + # The spec for the nexus endpoint. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec)).void } + def spec=(value) + end + + # The spec for the nexus endpoint. + sig { void } + def clear_spec + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateNexusEndpointRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNexusEndpointRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNexusEndpointRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNexusEndpointRequest, 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::Cloud::CloudService::V1::CreateNexusEndpointResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint_id: T.nilable(String), + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + endpoint_id: "", + async_operation: nil + ) + end + + # The id of the endpoint that was created. + sig { returns(String) } + def endpoint_id + end + + # The id of the endpoint that was created. + sig { params(value: String).void } + def endpoint_id=(value) + end + + # The id of the endpoint that was created. + sig { void } + def clear_endpoint_id + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateNexusEndpointResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNexusEndpointResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNexusEndpointResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNexusEndpointResponse, 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::Cloud::CloudService::V1::UpdateNexusEndpointRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint_id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + endpoint_id: "", + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The id of the nexus endpoint to update. + sig { returns(String) } + def endpoint_id + end + + # The id of the nexus endpoint to update. + sig { params(value: String).void } + def endpoint_id=(value) + end + + # The id of the nexus endpoint to update. + sig { void } + def clear_endpoint_id + end + + # The updated nexus endpoint specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec)) } + def spec + end + + # The updated nexus endpoint specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec)).void } + def spec=(value) + end + + # The updated nexus endpoint specification. + sig { void } + def clear_spec + end + + # The version of the nexus endpoint for which this update is intended for. +# The latest version can be found in the GetNexusEndpoint operation response. + sig { returns(String) } + def resource_version + end + + # The version of the nexus endpoint for which this update is intended for. +# The latest version can be found in the GetNexusEndpoint operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the nexus endpoint for which this update is intended for. +# The latest version can be found in the GetNexusEndpoint operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateNexusEndpointRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNexusEndpointRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNexusEndpointRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNexusEndpointRequest, 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::Cloud::CloudService::V1::UpdateNexusEndpointResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateNexusEndpointResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNexusEndpointResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNexusEndpointResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNexusEndpointResponse, 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::Cloud::CloudService::V1::DeleteNexusEndpointRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint_id: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + endpoint_id: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The id of the nexus endpoint to delete. + sig { returns(String) } + def endpoint_id + end + + # The id of the nexus endpoint to delete. + sig { params(value: String).void } + def endpoint_id=(value) + end + + # The id of the nexus endpoint to delete. + sig { void } + def clear_endpoint_id + end + + # The version of the endpoint for which this delete is intended for. +# The latest version can be found in the GetNexusEndpoint operation response. + sig { returns(String) } + def resource_version + end + + # The version of the endpoint for which this delete is intended for. +# The latest version can be found in the GetNexusEndpoint operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the endpoint for which this delete is intended for. +# The latest version can be found in the GetNexusEndpoint operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteNexusEndpointRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNexusEndpointRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNexusEndpointRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNexusEndpointRequest, 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::Cloud::CloudService::V1::DeleteNexusEndpointResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteNexusEndpointResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNexusEndpointResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNexusEndpointResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNexusEndpointResponse, 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::Cloud::CloudService::V1::GetUserGroupsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String), + namespace: T.nilable(String), + display_name: T.nilable(String), + google_group: T.nilable(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::GoogleGroupFilter), + scim_group: T.nilable(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::SCIMGroupFilter) + ).void + end + def initialize( + page_size: 0, + page_token: "", + namespace: "", + display_name: "", + google_group: nil, + scim_group: nil + ) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + end + + # Filter groups by the namespace they have access to - optional. + sig { returns(String) } + def namespace + end + + # Filter groups by the namespace they have access to - optional. + sig { params(value: String).void } + def namespace=(value) + end + + # Filter groups by the namespace they have access to - optional. + sig { void } + def clear_namespace + end + + # Filter groups by the display name - optional. + sig { returns(String) } + def display_name + end + + # Filter groups by the display name - optional. + sig { params(value: String).void } + def display_name=(value) + end + + # Filter groups by the display name - optional. + sig { void } + def clear_display_name + end + + # Filter groups by the google group specification - optional. + sig { returns(T.nilable(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::GoogleGroupFilter)) } + def google_group + end + + # Filter groups by the google group specification - optional. + sig { params(value: T.nilable(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::GoogleGroupFilter)).void } + def google_group=(value) + end + + # Filter groups by the google group specification - optional. + sig { void } + def clear_google_group + end + + # Filter groups by the SCIM group specification - optional. + sig { returns(T.nilable(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::SCIMGroupFilter)) } + def scim_group + end + + # Filter groups by the SCIM group specification - optional. + sig { params(value: T.nilable(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::SCIMGroupFilter)).void } + def scim_group=(value) + end + + # Filter groups by the SCIM group specification - optional. + sig { void } + def clear_scim_group + 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::Cloud::CloudService::V1::GetUserGroupsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest, 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::Cloud::CloudService::V1::GetUserGroupsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + groups: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroup)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + groups: [], + next_page_token: "" + ) + end + + # The list of groups in ascending name order. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroup)]) } + def groups + end + + # The list of groups in ascending name order. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def groups=(value) + end + + # The list of groups in ascending name order. + sig { void } + def clear_groups + end + + # The next page's token. + sig { returns(String) } + def next_page_token + end + + # The next page's token. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page's token. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetUserGroupsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsResponse, 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::Cloud::CloudService::V1::GetUserGroupRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_id: T.nilable(String) + ).void + end + def initialize( + group_id: "" + ) + end + + # The id of the group to get. + sig { returns(String) } + def group_id + end + + # The id of the group to get. + sig { params(value: String).void } + def group_id=(value) + end + + # The id of the group to get. + sig { void } + def clear_group_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::Cloud::CloudService::V1::GetUserGroupRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupRequest, 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::Cloud::CloudService::V1::GetUserGroupResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroup) + ).void + end + def initialize( + group: nil + ) + end + + # The group. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroup)) } + def group + end + + # The group. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroup)).void } + def group=(value) + end + + # The group. + sig { void } + def clear_group + 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::Cloud::CloudService::V1::GetUserGroupResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupResponse, 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::Cloud::CloudService::V1::CreateUserGroupRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + async_operation_id: "" + ) + end + + # The spec for the group to create. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec)) } + def spec + end + + # The spec for the group to create. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec)).void } + def spec=(value) + end + + # The spec for the group to create. + sig { void } + def clear_spec + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateUserGroupRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateUserGroupRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateUserGroupRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateUserGroupRequest, 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::Cloud::CloudService::V1::CreateUserGroupResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_id: T.nilable(String), + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + group_id: "", + async_operation: nil + ) + end + + # The id of the group that was created. + sig { returns(String) } + def group_id + end + + # The id of the group that was created. + sig { params(value: String).void } + def group_id=(value) + end + + # The id of the group that was created. + sig { void } + def clear_group_id + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateUserGroupResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateUserGroupResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateUserGroupResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateUserGroupResponse, 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::Cloud::CloudService::V1::UpdateUserGroupRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + group_id: "", + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The id of the group to update. + sig { returns(String) } + def group_id + end + + # The id of the group to update. + sig { params(value: String).void } + def group_id=(value) + end + + # The id of the group to update. + sig { void } + def clear_group_id + end + + # The new group specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec)) } + def spec + end + + # The new group specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec)).void } + def spec=(value) + end + + # The new group specification. + sig { void } + def clear_spec + end + + # The version of the group for which this update is intended for. +# The latest version can be found in the GetGroup operation response. + sig { returns(String) } + def resource_version + end + + # The version of the group for which this update is intended for. +# The latest version can be found in the GetGroup operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the group for which this update is intended for. +# The latest version can be found in the GetGroup operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateUserGroupRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateUserGroupRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateUserGroupRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateUserGroupRequest, 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::Cloud::CloudService::V1::UpdateUserGroupResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateUserGroupResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateUserGroupResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateUserGroupResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateUserGroupResponse, 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::Cloud::CloudService::V1::DeleteUserGroupRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_id: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + group_id: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The id of the group to delete. + sig { returns(String) } + def group_id + end + + # The id of the group to delete. + sig { params(value: String).void } + def group_id=(value) + end + + # The id of the group to delete. + sig { void } + def clear_group_id + end + + # The version of the group for which this delete is intended for. +# The latest version can be found in the GetGroup operation response. + sig { returns(String) } + def resource_version + end + + # The version of the group for which this delete is intended for. +# The latest version can be found in the GetGroup operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the group for which this delete is intended for. +# The latest version can be found in the GetGroup operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteUserGroupRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteUserGroupRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteUserGroupRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteUserGroupRequest, 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::Cloud::CloudService::V1::DeleteUserGroupResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteUserGroupResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteUserGroupResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteUserGroupResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteUserGroupResponse, 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::Cloud::CloudService::V1::SetUserGroupNamespaceAccessRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + group_id: T.nilable(String), + access: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + group_id: "", + access: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to set permissions for. + sig { returns(String) } + def namespace + end + + # The namespace to set permissions for. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to set permissions for. + sig { void } + def clear_namespace + end + + # The id of the group to set permissions for. + sig { returns(String) } + def group_id + end + + # The id of the group to set permissions for. + sig { params(value: String).void } + def group_id=(value) + end + + # The id of the group to set permissions for. + sig { void } + def clear_group_id + end + + # The namespace access to assign the group. If left empty, the group will be removed from the namespace access. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)) } + def access + end + + # The namespace access to assign the group. If left empty, the group will be removed from the namespace access. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)).void } + def access=(value) + end + + # The namespace access to assign the group. If left empty, the group will be removed from the namespace access. + sig { void } + def clear_access + end + + # The version of the group for which this update is intended for. +# The latest version can be found in the GetGroup operation response. + sig { returns(String) } + def resource_version + end + + # The version of the group for which this update is intended for. +# The latest version can be found in the GetGroup operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the group for which this update is intended for. +# The latest version can be found in the GetGroup operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::SetUserGroupNamespaceAccessRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetUserGroupNamespaceAccessRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::SetUserGroupNamespaceAccessRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetUserGroupNamespaceAccessRequest, 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::Cloud::CloudService::V1::SetUserGroupNamespaceAccessResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::SetUserGroupNamespaceAccessResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetUserGroupNamespaceAccessResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::SetUserGroupNamespaceAccessResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetUserGroupNamespaceAccessResponse, 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::Cloud::CloudService::V1::AddUserGroupMemberRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_id: T.nilable(String), + member_id: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + group_id: "", + member_id: nil, + async_operation_id: "" + ) + end + + # The id of the group to add the member for. + sig { returns(String) } + def group_id + end + + # The id of the group to add the member for. + sig { params(value: String).void } + def group_id=(value) + end + + # The id of the group to add the member for. + sig { void } + def clear_group_id + end + + # The member id to add to the group. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId)) } + def member_id + end + + # The member id to add to the group. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId)).void } + def member_id=(value) + end + + # The member id to add to the group. + sig { void } + def clear_member_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::AddUserGroupMemberRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberRequest, 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::Cloud::CloudService::V1::AddUserGroupMemberResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::AddUserGroupMemberResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberResponse, 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::Cloud::CloudService::V1::RemoveUserGroupMemberRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_id: T.nilable(String), + member_id: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + group_id: "", + member_id: nil, + async_operation_id: "" + ) + end + + # The id of the group to add the member for. + sig { returns(String) } + def group_id + end + + # The id of the group to add the member for. + sig { params(value: String).void } + def group_id=(value) + end + + # The id of the group to add the member for. + sig { void } + def clear_group_id + end + + # The member id to add to the group. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId)) } + def member_id + end + + # The member id to add to the group. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId)).void } + def member_id=(value) + end + + # The member id to add to the group. + sig { void } + def clear_member_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::RemoveUserGroupMemberRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberRequest, 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::Cloud::CloudService::V1::RemoveUserGroupMemberResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::RemoveUserGroupMemberResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberResponse, 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::Cloud::CloudService::V1::GetUserGroupMembersRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String), + group_id: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + page_token: "", + group_id: "" + ) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + end + + # The group id to list members of. + sig { returns(String) } + def group_id + end + + # The group id to list members of. + sig { params(value: String).void } + def group_id=(value) + end + + # The group id to list members of. + sig { void } + def clear_group_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::Cloud::CloudService::V1::GetUserGroupMembersRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersRequest, 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::Cloud::CloudService::V1::GetUserGroupMembersResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + members: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMember)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + members: [], + next_page_token: "" + ) + end + + # The list of group members + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMember)]) } + def members + end + + # The list of group members + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def members=(value) + end + + # The list of group members + sig { void } + def clear_members + end + + # The next page's token. + sig { returns(String) } + def next_page_token + end + + # The next page's token. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page's token. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetUserGroupMembersResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersResponse, 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::Cloud::CloudService::V1::CreateServiceAccountRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + async_operation_id: "" + ) + end + + # The spec of the service account to create. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec)) } + def spec + end + + # The spec of the service account to create. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec)).void } + def spec=(value) + end + + # The spec of the service account to create. + sig { void } + def clear_spec + end + + # The ID to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The ID to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateServiceAccountRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountRequest, 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::Cloud::CloudService::V1::CreateServiceAccountResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service_account_id: T.nilable(String), + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + service_account_id: "", + async_operation: nil + ) + end + + # The ID of the created service account. + sig { returns(String) } + def service_account_id + end + + # The ID of the created service account. + sig { params(value: String).void } + def service_account_id=(value) + end + + # The ID of the created service account. + sig { void } + def clear_service_account_id + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateServiceAccountResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountResponse, 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::Cloud::CloudService::V1::GetServiceAccountRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service_account_id: T.nilable(String) + ).void + end + def initialize( + service_account_id: "" + ) + end + + # ID of the service account to retrieve. + sig { returns(String) } + def service_account_id + end + + # ID of the service account to retrieve. + sig { params(value: String).void } + def service_account_id=(value) + end + + # ID of the service account to retrieve. + sig { void } + def clear_service_account_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::Cloud::CloudService::V1::GetServiceAccountRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountRequest, 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::Cloud::CloudService::V1::GetServiceAccountResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service_account: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccount) + ).void + end + def initialize( + service_account: nil + ) + end + + # The service account retrieved. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccount)) } + def service_account + end + + # The service account retrieved. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccount)).void } + def service_account=(value) + end + + # The service account retrieved. + sig { void } + def clear_service_account + 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::Cloud::CloudService::V1::GetServiceAccountResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountResponse, 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::Cloud::CloudService::V1::GetServiceAccountsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + page_token: "" + ) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + 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::Cloud::CloudService::V1::GetServiceAccountsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountsRequest, 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::Cloud::CloudService::V1::GetServiceAccountsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service_account: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccount)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + service_account: [], + next_page_token: "" + ) + end + + # The list of service accounts in ascending ID order. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccount)]) } + def service_account + end + + # The list of service accounts in ascending ID order. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def service_account=(value) + end + + # The list of service accounts in ascending ID order. + sig { void } + def clear_service_account + end + + # The next page token, set if there is another page. + sig { returns(String) } + def next_page_token + end + + # The next page token, set if there is another page. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page token, set if there is another page. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetServiceAccountsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountsResponse, 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::Cloud::CloudService::V1::UpdateServiceAccountRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service_account_id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + service_account_id: "", + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The ID of the service account to update. + sig { returns(String) } + def service_account_id + end + + # The ID of the service account to update. + sig { params(value: String).void } + def service_account_id=(value) + end + + # The ID of the service account to update. + sig { void } + def clear_service_account_id + end + + # The new service account specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec)) } + def spec + end + + # The new service account specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec)).void } + def spec=(value) + end + + # The new service account specification. + sig { void } + def clear_spec + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { returns(String) } + def resource_version + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { void } + def clear_resource_version + end + + # The ID to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The ID to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateServiceAccountRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateServiceAccountRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateServiceAccountRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateServiceAccountRequest, 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::Cloud::CloudService::V1::UpdateServiceAccountResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateServiceAccountResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateServiceAccountResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateServiceAccountResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateServiceAccountResponse, 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::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service_account_id: T.nilable(String), + namespace: T.nilable(String), + access: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + service_account_id: "", + namespace: "", + access: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The ID of the service account to update. + sig { returns(String) } + def service_account_id + end + + # The ID of the service account to update. + sig { params(value: String).void } + def service_account_id=(value) + end + + # The ID of the service account to update. + sig { void } + def clear_service_account_id + end + + # The namespace to set permissions for. + sig { returns(String) } + def namespace + end + + # The namespace to set permissions for. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to set permissions for. + sig { void } + def clear_namespace + end + + # The namespace access to assign the service account. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)) } + def access + end + + # The namespace access to assign the service account. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)).void } + def access=(value) + end + + # The namespace access to assign the service account. + sig { void } + def clear_access + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { returns(String) } + def resource_version + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { void } + def clear_resource_version + end + + # The ID to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The ID to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessRequest, 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::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessResponse, 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::Cloud::CloudService::V1::DeleteServiceAccountRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service_account_id: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + service_account_id: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The ID of the service account to delete; + sig { returns(String) } + def service_account_id + end + + # The ID of the service account to delete; + sig { params(value: String).void } + def service_account_id=(value) + end + + # The ID of the service account to delete; + sig { void } + def clear_service_account_id + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { returns(String) } + def resource_version + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the service account for which this update is intended for. +# The latest version can be found in the GetServiceAccount response. + sig { void } + def clear_resource_version + end + + # The ID to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The ID to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteServiceAccountRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteServiceAccountRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteServiceAccountRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteServiceAccountRequest, 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::Cloud::CloudService::V1::DeleteServiceAccountResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteServiceAccountResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteServiceAccountResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteServiceAccountResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteServiceAccountResponse, 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::Cloud::CloudService::V1::GetUsageRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_time_inclusive: T.nilable(Google::Protobuf::Timestamp), + end_time_exclusive: T.nilable(Google::Protobuf::Timestamp), + page_size: T.nilable(Integer), + page_token: T.nilable(String) + ).void + end + def initialize( + start_time_inclusive: nil, + end_time_exclusive: nil, + page_size: 0, + page_token: "" + ) + end + + # Filter for UTC time >= - optional. +# Defaults to: start of the current month. +# Must be: within the last 90 days from the current date. +# Must be: midnight UTC time. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time_inclusive + end + + # Filter for UTC time >= - optional. +# Defaults to: start of the current month. +# Must be: within the last 90 days from the current date. +# Must be: midnight UTC time. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time_inclusive=(value) + end + + # Filter for UTC time >= - optional. +# Defaults to: start of the current month. +# Must be: within the last 90 days from the current date. +# Must be: midnight UTC time. + sig { void } + def clear_start_time_inclusive + end + + # Filter for UTC time < - optional. +# Defaults to: start of the next UTC day. +# Must be: within the last 90 days from the current date. +# Must be: midnight UTC time. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def end_time_exclusive + end + + # Filter for UTC time < - optional. +# Defaults to: start of the next UTC day. +# Must be: within the last 90 days from the current date. +# Must be: midnight UTC time. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def end_time_exclusive=(value) + end + + # Filter for UTC time < - optional. +# Defaults to: start of the next UTC day. +# Must be: within the last 90 days from the current date. +# Must be: midnight UTC time. + sig { void } + def clear_end_time_exclusive + end + + # The requested size of the page to retrieve - optional. +# Each count corresponds to a single object - per day per namespace +# Cannot exceed 1000. Defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve - optional. +# Each count corresponds to a single object - per day per namespace +# Cannot exceed 1000. Defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve - optional. +# Each count corresponds to a single object - per day per namespace +# Cannot exceed 1000. Defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + 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::Cloud::CloudService::V1::GetUsageRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUsageRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUsageRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUsageRequest, 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::Cloud::CloudService::V1::GetUsageResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + summaries: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Usage::V1::Summary)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + summaries: [], + next_page_token: "" + ) + end + + # The list of data based on granularity (per Day for now) +# Ordered by: time range in ascending order + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Usage::V1::Summary)]) } + def summaries + end + + # The list of data based on granularity (per Day for now) +# Ordered by: time range in ascending order + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def summaries=(value) + end + + # The list of data based on granularity (per Day for now) +# Ordered by: time range in ascending order + sig { void } + def clear_summaries + end + + # The next page's token. + sig { returns(String) } + def next_page_token + end + + # The next page's token. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page's token. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetUsageResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUsageResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUsageResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUsageResponse, 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::Cloud::CloudService::V1::GetAccountRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::CloudService::V1::GetAccountRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountRequest, 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::Cloud::CloudService::V1::GetAccountResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + account: T.nilable(Temporalio::Api::Cloud::Account::V1::Account) + ).void + end + def initialize( + account: nil + ) + end + + # The account. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::Account)) } + def account + end + + # The account. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::Account)).void } + def account=(value) + end + + # The account. + sig { void } + def clear_account + 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::Cloud::CloudService::V1::GetAccountResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountResponse, 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::Cloud::CloudService::V1::UpdateAccountRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Account::V1::AccountSpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The updated account specification to apply. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::AccountSpec)) } + def spec + end + + # The updated account specification to apply. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::AccountSpec)).void } + def spec=(value) + end + + # The updated account specification to apply. + sig { void } + def clear_spec + end + + # The version of the account for which this update is intended for. +# The latest version can be found in the GetAccount operation response. + sig { returns(String) } + def resource_version + end + + # The version of the account for which this update is intended for. +# The latest version can be found in the GetAccount operation response. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the account for which this update is intended for. +# The latest version can be found in the GetAccount operation response. + sig { void } + def clear_resource_version + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateAccountRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateAccountRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountRequest, 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::Cloud::CloudService::V1::UpdateAccountResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateAccountResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateAccountResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountResponse, 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::Cloud::CloudService::V1::CreateNamespaceExportSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + spec: nil, + async_operation_id: "" + ) + end + + # The namespace under which the sink is configured. + sig { returns(String) } + def namespace + end + + # The namespace under which the sink is configured. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace under which the sink is configured. + sig { void } + def clear_namespace + end + + # The specification for the export sink. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec)) } + def spec + end + + # The specification for the export sink. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec)).void } + def spec=(value) + end + + # The specification for the export sink. + sig { void } + def clear_spec + end + + # Optional. The ID to use for this async operation. + sig { returns(String) } + def async_operation_id + end + + # Optional. The ID to use for this async operation. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # Optional. The ID to use for this async operation. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateNamespaceExportSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceExportSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceExportSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceExportSinkRequest, 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::Cloud::CloudService::V1::CreateNamespaceExportSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateNamespaceExportSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceExportSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceExportSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceExportSinkResponse, 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::Cloud::CloudService::V1::GetNamespaceExportSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + name: T.nilable(String) + ).void + end + def initialize( + namespace: "", + name: "" + ) + end + + # The namespace to which the sink belongs. + sig { returns(String) } + def namespace + end + + # The namespace to which the sink belongs. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to which the sink belongs. + sig { void } + def clear_namespace + end + + # The name of the sink to retrieve. + sig { returns(String) } + def name + end + + # The name of the sink to retrieve. + sig { params(value: String).void } + def name=(value) + end + + # The name of the sink to retrieve. + sig { void } + def clear_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::Cloud::CloudService::V1::GetNamespaceExportSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinkRequest, 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::Cloud::CloudService::V1::GetNamespaceExportSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + sink: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSink) + ).void + end + def initialize( + sink: nil + ) + end + + # The export sink retrieved. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSink)) } + def sink + end + + # The export sink retrieved. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSink)).void } + def sink=(value) + end + + # The export sink retrieved. + sig { void } + def clear_sink + 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::Cloud::CloudService::V1::GetNamespaceExportSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinkResponse, 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::Cloud::CloudService::V1::GetNamespaceExportSinksRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + page_token: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + page_token: "" + ) + end + + # The namespace to which the sinks belong. + sig { returns(String) } + def namespace + end + + # The namespace to which the sinks belong. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to which the sinks belong. + sig { void } + def clear_namespace + end + + # The requested size of the page to retrieve. Cannot exceed 1000. +# Defaults to 100 if not specified. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve. Cannot exceed 1000. +# Defaults to 100 if not specified. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve. Cannot exceed 1000. +# Defaults to 100 if not specified. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + 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::Cloud::CloudService::V1::GetNamespaceExportSinksRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinksRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinksRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinksRequest, 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::Cloud::CloudService::V1::GetNamespaceExportSinksResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + sinks: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSink)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + sinks: [], + next_page_token: "" + ) + end + + # The list of export sinks retrieved. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSink)]) } + def sinks + end + + # The list of export sinks retrieved. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def sinks=(value) + end + + # The list of export sinks retrieved. + sig { void } + def clear_sinks + end + + # The next page token, set if there is another page. + sig { returns(String) } + def next_page_token + end + + # The next page token, set if there is another page. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page token, set if there is another page. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetNamespaceExportSinksResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinksResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinksResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinksResponse, 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::Cloud::CloudService::V1::UpdateNamespaceExportSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to which the sink belongs. + sig { returns(String) } + def namespace + end + + # The namespace to which the sink belongs. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to which the sink belongs. + sig { void } + def clear_namespace + end + + # The updated export sink specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec)) } + def spec + end + + # The updated export sink specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec)).void } + def spec=(value) + end + + # The updated export sink specification. + sig { void } + def clear_spec + end + + # The version of the sink to update. The latest version can be +# retrieved using the GetNamespaceExportSink call. + sig { returns(String) } + def resource_version + end + + # The version of the sink to update. The latest version can be +# retrieved using the GetNamespaceExportSink call. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the sink to update. The latest version can be +# retrieved using the GetNamespaceExportSink call. + sig { void } + def clear_resource_version + end + + # The ID to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The ID to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateNamespaceExportSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceExportSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceExportSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceExportSinkRequest, 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::Cloud::CloudService::V1::UpdateNamespaceExportSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateNamespaceExportSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceExportSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceExportSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceExportSinkResponse, 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::Cloud::CloudService::V1::DeleteNamespaceExportSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + name: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + name: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The namespace to which the sink belongs. + sig { returns(String) } + def namespace + end + + # The namespace to which the sink belongs. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to which the sink belongs. + sig { void } + def clear_namespace + end + + # The name of the sink to delete. + sig { returns(String) } + def name + end + + # The name of the sink to delete. + sig { params(value: String).void } + def name=(value) + end + + # The name of the sink to delete. + sig { void } + def clear_name + end + + # The version of the sink to delete. The latest version can be +# retrieved using the GetNamespaceExportSink call. + sig { returns(String) } + def resource_version + end + + # The version of the sink to delete. The latest version can be +# retrieved using the GetNamespaceExportSink call. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the sink to delete. The latest version can be +# retrieved using the GetNamespaceExportSink call. + sig { void } + def clear_resource_version + end + + # The ID to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The ID to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteNamespaceExportSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceExportSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceExportSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceExportSinkRequest, 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::Cloud::CloudService::V1::DeleteNamespaceExportSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteNamespaceExportSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceExportSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceExportSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceExportSinkResponse, 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::Cloud::CloudService::V1::ValidateNamespaceExportSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec) + ).void + end + def initialize( + namespace: "", + spec: nil + ) + end + + # The namespace to which the sink belongs. + sig { returns(String) } + def namespace + end + + # The namespace to which the sink belongs. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to which the sink belongs. + sig { void } + def clear_namespace + end + + # The export sink specification to validate. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec)) } + def spec + end + + # The export sink specification to validate. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec)).void } + def spec=(value) + end + + # The export sink specification to validate. + sig { void } + def clear_spec + 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::Cloud::CloudService::V1::ValidateNamespaceExportSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::ValidateNamespaceExportSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::ValidateNamespaceExportSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::ValidateNamespaceExportSinkRequest, 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::Cloud::CloudService::V1::ValidateNamespaceExportSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::CloudService::V1::ValidateNamespaceExportSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::ValidateNamespaceExportSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::ValidateNamespaceExportSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::ValidateNamespaceExportSinkResponse, 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::Cloud::CloudService::V1::UpdateNamespaceTagsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + tags_to_upsert: T.nilable(T::Hash[String, String]), + tags_to_remove: T.nilable(T::Array[String]), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + tags_to_upsert: ::Google::Protobuf::Map.new(:string, :string), + tags_to_remove: [], + async_operation_id: "" + ) + end + + # The namespace to set tags for. + sig { returns(String) } + def namespace + end + + # The namespace to set tags for. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to set tags for. + sig { void } + def clear_namespace + end + + # A list of tags to add or update. +# If a key of an existing tag is added, the tag's value is updated. +# At least one of tags_to_upsert or tags_to_remove must be specified. + sig { returns(T::Hash[String, String]) } + def tags_to_upsert + end + + # A list of tags to add or update. +# If a key of an existing tag is added, the tag's value is updated. +# At least one of tags_to_upsert or tags_to_remove must be specified. + sig { params(value: ::Google::Protobuf::Map).void } + def tags_to_upsert=(value) + end + + # A list of tags to add or update. +# If a key of an existing tag is added, the tag's value is updated. +# At least one of tags_to_upsert or tags_to_remove must be specified. + sig { void } + def clear_tags_to_upsert + end + + # A list of tag keys to remove. +# If a tag key doesn't exist, it is silently ignored. +# At least one of tags_to_upsert or tags_to_remove must be specified. + sig { returns(T::Array[String]) } + def tags_to_remove + end + + # A list of tag keys to remove. +# If a tag key doesn't exist, it is silently ignored. +# At least one of tags_to_upsert or tags_to_remove must be specified. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def tags_to_remove=(value) + end + + # A list of tag keys to remove. +# If a tag key doesn't exist, it is silently ignored. +# At least one of tags_to_upsert or tags_to_remove must be specified. + sig { void } + def clear_tags_to_remove + end + + # The id to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateNamespaceTagsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceTagsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceTagsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceTagsRequest, 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::Cloud::CloudService::V1::UpdateNamespaceTagsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateNamespaceTagsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceTagsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceTagsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceTagsResponse, 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::Cloud::CloudService::V1::CreateConnectivityRuleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + async_operation_id: "" + ) + end + + # The connectivity rule specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec)) } + def spec + end + + # The connectivity rule specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec)).void } + def spec=(value) + end + + # The connectivity rule specification. + sig { void } + def clear_spec + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateConnectivityRuleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateConnectivityRuleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateConnectivityRuleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateConnectivityRuleRequest, 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::Cloud::CloudService::V1::CreateConnectivityRuleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + connectivity_rule_id: T.nilable(String), + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + connectivity_rule_id: "", + async_operation: nil + ) + end + + # The id of the connectivity rule that was created. + sig { returns(String) } + def connectivity_rule_id + end + + # The id of the connectivity rule that was created. + sig { params(value: String).void } + def connectivity_rule_id=(value) + end + + # The id of the connectivity rule that was created. + sig { void } + def clear_connectivity_rule_id + end + + # The async operation + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateConnectivityRuleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateConnectivityRuleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateConnectivityRuleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateConnectivityRuleResponse, 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::Cloud::CloudService::V1::GetConnectivityRuleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + connectivity_rule_id: T.nilable(String) + ).void + end + def initialize( + connectivity_rule_id: "" + ) + end + + # The id of the connectivity rule to get. + sig { returns(String) } + def connectivity_rule_id + end + + # The id of the connectivity rule to get. + sig { params(value: String).void } + def connectivity_rule_id=(value) + end + + # The id of the connectivity rule to get. + sig { void } + def clear_connectivity_rule_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::Cloud::CloudService::V1::GetConnectivityRuleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRuleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRuleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRuleRequest, 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::Cloud::CloudService::V1::GetConnectivityRuleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + connectivity_rule: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule) + ).void + end + def initialize( + connectivity_rule: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule)) } + def connectivity_rule + end + + sig { params(value: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule)).void } + def connectivity_rule=(value) + end + + sig { void } + def clear_connectivity_rule + 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::Cloud::CloudService::V1::GetConnectivityRuleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRuleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRuleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRuleResponse, 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::Cloud::CloudService::V1::GetConnectivityRulesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String), + namespace: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + page_token: "", + namespace: "" + ) + end + + # The requested size of the page to retrieve. +# Optional, defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve. +# Optional, defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve. +# Optional, defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response. +# Optional, defaults to empty. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response. +# Optional, defaults to empty. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response. +# Optional, defaults to empty. + sig { void } + def clear_page_token + end + + # Filter connectivity rule by the namespace id. + sig { returns(String) } + def namespace + end + + # Filter connectivity rule by the namespace id. + sig { params(value: String).void } + def namespace=(value) + end + + # Filter connectivity rule by the namespace id. + sig { void } + def clear_namespace + 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::Cloud::CloudService::V1::GetConnectivityRulesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRulesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRulesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRulesRequest, 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::Cloud::CloudService::V1::GetConnectivityRulesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + connectivity_rules: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + connectivity_rules: [], + next_page_token: "" + ) + end + + # connectivity_rules returned + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule)]) } + def connectivity_rules + end + + # connectivity_rules returned + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def connectivity_rules=(value) + end + + # connectivity_rules returned + sig { void } + def clear_connectivity_rules + end + + # The next page token + sig { returns(String) } + def next_page_token + end + + # The next page token + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page token + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetConnectivityRulesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRulesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRulesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRulesResponse, 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::Cloud::CloudService::V1::DeleteConnectivityRuleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + connectivity_rule_id: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + connectivity_rule_id: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The ID of the connectivity rule that need be deleted, required. + sig { returns(String) } + def connectivity_rule_id + end + + # The ID of the connectivity rule that need be deleted, required. + sig { params(value: String).void } + def connectivity_rule_id=(value) + end + + # The ID of the connectivity rule that need be deleted, required. + sig { void } + def clear_connectivity_rule_id + end + + # The resource version which should be the same from the the db, required +# The latest version can be found in the GetConnectivityRule operation response + sig { returns(String) } + def resource_version + end + + # The resource version which should be the same from the the db, required +# The latest version can be found in the GetConnectivityRule operation response + sig { params(value: String).void } + def resource_version=(value) + end + + # The resource version which should be the same from the the db, required +# The latest version can be found in the GetConnectivityRule operation response + sig { void } + def clear_resource_version + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id to use for this async operation. +# Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteConnectivityRuleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteConnectivityRuleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteConnectivityRuleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteConnectivityRuleRequest, 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::Cloud::CloudService::V1::DeleteConnectivityRuleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteConnectivityRuleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteConnectivityRuleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteConnectivityRuleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteConnectivityRuleResponse, 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::Cloud::CloudService::V1::GetAuditLogsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String), + start_time_inclusive: T.nilable(Google::Protobuf::Timestamp), + end_time_exclusive: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + page_size: 0, + page_token: "", + start_time_inclusive: nil, + end_time_exclusive: nil + ) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve - optional. +# Cannot exceed 1000. Defaults to 100. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + end + + # Filter for UTC time >= (defaults to 30 days ago) - optional. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time_inclusive + end + + # Filter for UTC time >= (defaults to 30 days ago) - optional. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time_inclusive=(value) + end + + # Filter for UTC time >= (defaults to 30 days ago) - optional. + sig { void } + def clear_start_time_inclusive + end + + # Filter for UTC time < (defaults to current time) - optional. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def end_time_exclusive + end + + # Filter for UTC time < (defaults to current time) - optional. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def end_time_exclusive=(value) + end + + # Filter for UTC time < (defaults to current time) - optional. + sig { void } + def clear_end_time_exclusive + 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::Cloud::CloudService::V1::GetAuditLogsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAuditLogsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAuditLogsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAuditLogsRequest, 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::Cloud::CloudService::V1::GetAuditLogsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + logs: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::AuditLog::V1::LogRecord)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + logs: [], + next_page_token: "" + ) + end + + # The list of audit logs ordered by emit time, log_id + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::AuditLog::V1::LogRecord)]) } + def logs + end + + # The list of audit logs ordered by emit time, log_id + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def logs=(value) + end + + # The list of audit logs ordered by emit time, log_id + sig { void } + def clear_logs + end + + # The next page's token. + sig { returns(String) } + def next_page_token + end + + # The next page's token. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page's token. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetAuditLogsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAuditLogsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAuditLogsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAuditLogsResponse, 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::Cloud::CloudService::V1::ValidateAccountAuditLogSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec) + ).void + end + def initialize( + spec: nil + ) + end + + # The audit log sink spec that will be validated + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec)) } + def spec + end + + # The audit log sink spec that will be validated + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec)).void } + def spec=(value) + end + + # The audit log sink spec that will be validated + sig { void } + def clear_spec + 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::Cloud::CloudService::V1::ValidateAccountAuditLogSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::ValidateAccountAuditLogSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::ValidateAccountAuditLogSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::ValidateAccountAuditLogSinkRequest, 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::Cloud::CloudService::V1::ValidateAccountAuditLogSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::CloudService::V1::ValidateAccountAuditLogSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::ValidateAccountAuditLogSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::ValidateAccountAuditLogSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::ValidateAccountAuditLogSinkResponse, 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::Cloud::CloudService::V1::CreateAccountAuditLogSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + async_operation_id: "" + ) + end + + # The specification for the audit log sink. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec)) } + def spec + end + + # The specification for the audit log sink. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec)).void } + def spec=(value) + end + + # The specification for the audit log sink. + sig { void } + def clear_spec + end + + # Optional. The ID to use for this async operation. + sig { returns(String) } + def async_operation_id + end + + # Optional. The ID to use for this async operation. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # Optional. The ID to use for this async operation. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateAccountAuditLogSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateAccountAuditLogSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateAccountAuditLogSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateAccountAuditLogSinkRequest, 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::Cloud::CloudService::V1::CreateAccountAuditLogSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateAccountAuditLogSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateAccountAuditLogSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateAccountAuditLogSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateAccountAuditLogSinkResponse, 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::Cloud::CloudService::V1::GetAccountAuditLogSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String) + ).void + end + def initialize( + name: "" + ) + end + + # The name of the sink to retrieve. + sig { returns(String) } + def name + end + + # The name of the sink to retrieve. + sig { params(value: String).void } + def name=(value) + end + + # The name of the sink to retrieve. + sig { void } + def clear_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::Cloud::CloudService::V1::GetAccountAuditLogSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinkRequest, 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::Cloud::CloudService::V1::GetAccountAuditLogSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + sink: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSink) + ).void + end + def initialize( + sink: nil + ) + end + + # The audit log sink retrieved. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSink)) } + def sink + end + + # The audit log sink retrieved. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSink)).void } + def sink=(value) + end + + # The audit log sink retrieved. + sig { void } + def clear_sink + 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::Cloud::CloudService::V1::GetAccountAuditLogSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinkResponse, 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::Cloud::CloudService::V1::GetAccountAuditLogSinksRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + page_token: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + page_token: "" + ) + end + + # The requested size of the page to retrieve. Cannot exceed 1000. +# Defaults to 100 if not specified. + sig { returns(Integer) } + def page_size + end + + # The requested size of the page to retrieve. Cannot exceed 1000. +# Defaults to 100 if not specified. + sig { params(value: Integer).void } + def page_size=(value) + end + + # The requested size of the page to retrieve. Cannot exceed 1000. +# Defaults to 100 if not specified. + sig { void } + def clear_page_size + end + + # The page token if this is continuing from another response - optional. + sig { returns(String) } + def page_token + end + + # The page token if this is continuing from another response - optional. + sig { params(value: String).void } + def page_token=(value) + end + + # The page token if this is continuing from another response - optional. + sig { void } + def clear_page_token + 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::Cloud::CloudService::V1::GetAccountAuditLogSinksRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinksRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinksRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinksRequest, 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::Cloud::CloudService::V1::GetAccountAuditLogSinksResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + sinks: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSink)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + sinks: [], + next_page_token: "" + ) + end + + # The list of audit log sinks retrieved. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSink)]) } + def sinks + end + + # The list of audit log sinks retrieved. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def sinks=(value) + end + + # The list of audit log sinks retrieved. + sig { void } + def clear_sinks + end + + # The next page token, set if there is another page. + sig { returns(String) } + def next_page_token + end + + # The next page token, set if there is another page. + sig { params(value: String).void } + def next_page_token=(value) + end + + # The next page token, set if there is another page. + sig { void } + def clear_next_page_token + 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::Cloud::CloudService::V1::GetAccountAuditLogSinksResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinksResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinksResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinksResponse, 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::Cloud::CloudService::V1::UpdateAccountAuditLogSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + resource_version: "", + async_operation_id: "" + ) + end + + # The updated audit log sink specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec)) } + def spec + end + + # The updated audit log sink specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Account::V1::AuditLogSinkSpec)).void } + def spec=(value) + end + + # The updated audit log sink specification. + sig { void } + def clear_spec + end + + # The version of the audit log sink to update. The latest version can be +# retrieved using the GetAuditLogSink call. + sig { returns(String) } + def resource_version + end + + # The version of the audit log sink to update. The latest version can be +# retrieved using the GetAuditLogSink call. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the audit log sink to update. The latest version can be +# retrieved using the GetAuditLogSink call. + sig { void } + def clear_resource_version + end + + # The ID to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The ID to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::UpdateAccountAuditLogSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountAuditLogSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateAccountAuditLogSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountAuditLogSinkRequest, 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::Cloud::CloudService::V1::UpdateAccountAuditLogSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::UpdateAccountAuditLogSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountAuditLogSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateAccountAuditLogSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountAuditLogSinkResponse, 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::Cloud::CloudService::V1::DeleteAccountAuditLogSinkRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + resource_version: T.nilable(String), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + name: "", + resource_version: "", + async_operation_id: "" + ) + end + + # The name of the sink to delete. + sig { returns(String) } + def name + end + + # The name of the sink to delete. + sig { params(value: String).void } + def name=(value) + end + + # The name of the sink to delete. + sig { void } + def clear_name + end + + # The version of the sink to delete. The latest version can be +# retrieved using the GetAccountAuditLogSink call. + sig { returns(String) } + def resource_version + end + + # The version of the sink to delete. The latest version can be +# retrieved using the GetAccountAuditLogSink call. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the sink to delete. The latest version can be +# retrieved using the GetAccountAuditLogSink call. + sig { void } + def clear_resource_version + end + + # The ID to use for this async operation - optional. + sig { returns(String) } + def async_operation_id + end + + # The ID to use for this async operation - optional. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The ID to use for this async operation - optional. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::DeleteAccountAuditLogSinkRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteAccountAuditLogSinkRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteAccountAuditLogSinkRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteAccountAuditLogSinkRequest, 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::Cloud::CloudService::V1::DeleteAccountAuditLogSinkResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + async_operation: nil + ) + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::DeleteAccountAuditLogSinkResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteAccountAuditLogSinkResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteAccountAuditLogSinkResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::DeleteAccountAuditLogSinkResponse, 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::Cloud::CloudService::V1::GetNamespaceCapacityInfoRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String) + ).void + end + def initialize( + namespace: "" + ) + end + + # The namespace identifier. +# Required. + sig { returns(String) } + def namespace + end + + # The namespace identifier. +# Required. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace identifier. +# Required. + sig { void } + def clear_namespace + 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::Cloud::CloudService::V1::GetNamespaceCapacityInfoRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceCapacityInfoRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceCapacityInfoRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceCapacityInfoRequest, 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::Cloud::CloudService::V1::GetNamespaceCapacityInfoResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + capacity_info: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo) + ).void + end + def initialize( + capacity_info: nil + ) + end + + # Capacity information for the namespace. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo)) } + def capacity_info + end + + # Capacity information for the namespace. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo)).void } + def capacity_info=(value) + end + + # Capacity information for the namespace. + sig { void } + def clear_capacity_info + 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::Cloud::CloudService::V1::GetNamespaceCapacityInfoResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceCapacityInfoResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceCapacityInfoResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceCapacityInfoResponse, 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::Cloud::CloudService::V1::CreateBillingReportRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReportSpec), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + spec: nil, + async_operation_id: "" + ) + end + + # The specification for the billing report. + sig { returns(T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReportSpec)) } + def spec + end + + # The specification for the billing report. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReportSpec)).void } + def spec=(value) + end + + # The specification for the billing report. + sig { void } + def clear_spec + end + + # Optional, if not provided a random id will be generated. + sig { returns(String) } + def async_operation_id + end + + # Optional, if not provided a random id will be generated. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # Optional, if not provided a random id will be generated. + sig { void } + def clear_async_operation_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::Cloud::CloudService::V1::CreateBillingReportRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateBillingReportRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateBillingReportRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateBillingReportRequest, 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::Cloud::CloudService::V1::CreateBillingReportResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + billing_report_id: T.nilable(String), + async_operation: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) + ).void + end + def initialize( + billing_report_id: "", + async_operation: nil + ) + end + + # The id of the billing report created. + sig { returns(String) } + def billing_report_id + end + + # The id of the billing report created. + sig { params(value: String).void } + def billing_report_id=(value) + end + + # The id of the billing report created. + sig { void } + def clear_billing_report_id + end + + # The async operation. + sig { returns(T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)) } + def async_operation + end + + # The async operation. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Operation::V1::AsyncOperation)).void } + def async_operation=(value) + end + + # The async operation. + sig { void } + def clear_async_operation + 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::Cloud::CloudService::V1::CreateBillingReportResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateBillingReportResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::CreateBillingReportResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::CreateBillingReportResponse, 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::Cloud::CloudService::V1::GetBillingReportRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + billing_report_id: T.nilable(String) + ).void + end + def initialize( + billing_report_id: "" + ) + end + + # The id of the billing report to retrieve. + sig { returns(String) } + def billing_report_id + end + + # The id of the billing report to retrieve. + sig { params(value: String).void } + def billing_report_id=(value) + end + + # The id of the billing report to retrieve. + sig { void } + def clear_billing_report_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::Cloud::CloudService::V1::GetBillingReportRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetBillingReportRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetBillingReportRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetBillingReportRequest, 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::Cloud::CloudService::V1::GetBillingReportResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + billing_report: T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReport) + ).void + end + def initialize( + billing_report: nil + ) + end + + # The billing report retrieved. + sig { returns(T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReport)) } + def billing_report + end + + # The billing report retrieved. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Billing::V1::BillingReport)).void } + def billing_report=(value) + end + + # The billing report retrieved. + sig { void } + def clear_billing_report + 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::Cloud::CloudService::V1::GetBillingReportResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetBillingReportResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetBillingReportResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetBillingReportResponse, 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::Cloud::CloudService::V1::GetUserGroupsRequest::GoogleGroupFilter + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + email_address: T.nilable(String) + ).void + end + def initialize( + email_address: "" + ) + end + + # Filter groups by the google group email - optional. + sig { returns(String) } + def email_address + end + + # Filter groups by the google group email - optional. + sig { params(value: String).void } + def email_address=(value) + end + + # Filter groups by the google group email - optional. + sig { void } + def clear_email_address + 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::Cloud::CloudService::V1::GetUserGroupsRequest::GoogleGroupFilter) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::GoogleGroupFilter).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::GoogleGroupFilter) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::GoogleGroupFilter, 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::Cloud::CloudService::V1::GetUserGroupsRequest::SCIMGroupFilter + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + idp_id: T.nilable(String) + ).void + end + def initialize( + idp_id: "" + ) + end + + # Filter groups by the SCIM IDP id - optional. + sig { returns(String) } + def idp_id + end + + # Filter groups by the SCIM IDP id - optional. + sig { params(value: String).void } + def idp_id=(value) + end + + # Filter groups by the SCIM IDP id - optional. + sig { void } + def clear_idp_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::Cloud::CloudService::V1::GetUserGroupsRequest::SCIMGroupFilter) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::SCIMGroupFilter).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::SCIMGroupFilter) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest::SCIMGroupFilter, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/cloudservice/v1/service.rbi b/temporalio/rbi/temporalio/api/cloud/cloudservice/v1/service.rbi new file mode 100644 index 00000000..671fe5d7 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/cloudservice/v1/service.rbi @@ -0,0 +1,3 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/cloudservice/v1/service.proto +# typed: strict diff --git a/temporalio/rbi/temporalio/api/cloud/connectivityrule/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/connectivityrule/v1/message.rbi new file mode 100644 index 00000000..b20fff01 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/connectivityrule/v1/message.rbi @@ -0,0 +1,378 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/connectivityrule/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec), + resource_version: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String), + created_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + id: "", + spec: nil, + resource_version: "", + state: :RESOURCE_STATE_UNSPECIFIED, + async_operation_id: "", + created_time: nil + ) + end + + # The id of the private connectivity rule. + sig { returns(String) } + def id + end + + # The id of the private connectivity rule. + sig { params(value: String).void } + def id=(value) + end + + # The id of the private connectivity rule. + sig { void } + def clear_id + end + + # The connectivity rule specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec)) } + def spec + end + + # The connectivity rule specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec)).void } + def spec=(value) + end + + # The connectivity rule specification. + sig { void } + def clear_spec + end + + # The current version of the connectivity rule specification. +# The next update operation will have to include this version. + sig { returns(String) } + def resource_version + end + + # The current version of the connectivity rule specification. +# The next update operation will have to include this version. + sig { params(value: String).void } + def resource_version=(value) + end + + # The current version of the connectivity rule specification. +# The next update operation will have to include this version. + sig { void } + def clear_resource_version + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + end + + # The id of the async operation that is creating/updating/deleting the connectivity rule, if any. + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is creating/updating/deleting the connectivity rule, if any. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is creating/updating/deleting the connectivity rule, if any. + sig { void } + def clear_async_operation_id + end + + # The date and time when the connectivity rule was created. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the connectivity rule was created. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the connectivity rule was created. + sig { void } + def clear_created_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::Cloud::ConnectivityRule::V1::ConnectivityRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# The connectivity rule specification passed in on create/update operations. +class Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + public_rule: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::PublicConnectivityRule), + private_rule: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::PrivateConnectivityRule) + ).void + end + def initialize( + public_rule: nil, + private_rule: nil + ) + end + + # This allows access via public internet. + sig { returns(T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::PublicConnectivityRule)) } + def public_rule + end + + # This allows access via public internet. + sig { params(value: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::PublicConnectivityRule)).void } + def public_rule=(value) + end + + # This allows access via public internet. + sig { void } + def clear_public_rule + end + + # This allows access via specific private vpc. + sig { returns(T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::PrivateConnectivityRule)) } + def private_rule + end + + # This allows access via specific private vpc. + sig { params(value: T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::PrivateConnectivityRule)).void } + def private_rule=(value) + end + + # This allows access via specific private vpc. + sig { void } + def clear_private_rule + end + + sig { returns(T.nilable(Symbol)) } + def connection_type + 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::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRuleSpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A public connectivity rule allows access to the namespace via the public internet. +class Temporalio::Api::Cloud::ConnectivityRule::V1::PublicConnectivityRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::ConnectivityRule::V1::PublicConnectivityRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::ConnectivityRule::V1::PublicConnectivityRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::ConnectivityRule::V1::PublicConnectivityRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::ConnectivityRule::V1::PublicConnectivityRule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A private connectivity rule allows connections from a specific private vpc only. +class Temporalio::Api::Cloud::ConnectivityRule::V1::PrivateConnectivityRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + connection_id: T.nilable(String), + gcp_project_id: T.nilable(String), + region: T.nilable(String) + ).void + end + def initialize( + connection_id: "", + gcp_project_id: "", + region: "" + ) + end + + # Connection id provided to enforce the private connectivity. This is required both by AWS and GCP. + sig { returns(String) } + def connection_id + end + + # Connection id provided to enforce the private connectivity. This is required both by AWS and GCP. + sig { params(value: String).void } + def connection_id=(value) + end + + # Connection id provided to enforce the private connectivity. This is required both by AWS and GCP. + sig { void } + def clear_connection_id + end + + # For GCP private connectivity service, GCP needs both GCP project id and the Private Service Connect Connection IDs +# AWS only needs the connection_id + sig { returns(String) } + def gcp_project_id + end + + # For GCP private connectivity service, GCP needs both GCP project id and the Private Service Connect Connection IDs +# AWS only needs the connection_id + sig { params(value: String).void } + def gcp_project_id=(value) + end + + # For GCP private connectivity service, GCP needs both GCP project id and the Private Service Connect Connection IDs +# AWS only needs the connection_id + sig { void } + def clear_gcp_project_id + end + + # The region of the connectivity rule. This should align with the namespace. +# Example: "aws-us-west-2" + sig { returns(String) } + def region + end + + # The region of the connectivity rule. This should align with the namespace. +# Example: "aws-us-west-2" + sig { params(value: String).void } + def region=(value) + end + + # The region of the connectivity rule. This should align with the namespace. +# Example: "aws-us-west-2" + sig { void } + def clear_region + 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::Cloud::ConnectivityRule::V1::PrivateConnectivityRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::ConnectivityRule::V1::PrivateConnectivityRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::ConnectivityRule::V1::PrivateConnectivityRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::ConnectivityRule::V1::PrivateConnectivityRule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/identity/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/identity/v1/message.rbi new file mode 100644 index 00000000..a3394188 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/identity/v1/message.rbi @@ -0,0 +1,2195 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/identity/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Identity::V1::AccountAccess + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + role_deprecated: T.nilable(String), + role: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + role_deprecated: "", + role: :ROLE_UNSPECIFIED + ) + end + + # The role on the account, should be one of [owner, admin, developer, financeadmin, read, metricsread] +# owner - gives full access to the account, including users, namespaces, and billing +# admin - gives full access the account, including users and namespaces +# developer - gives access to create namespaces on the account +# financeadmin - gives read only access and write access for billing +# read - gives read only access to the account +# metricsread - gives read only access to all namespace metrics +# Deprecated: Not supported after v0.3.0 api version. Use role instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def role_deprecated + end + + # The role on the account, should be one of [owner, admin, developer, financeadmin, read, metricsread] +# owner - gives full access to the account, including users, namespaces, and billing +# admin - gives full access the account, including users and namespaces +# developer - gives access to create namespaces on the account +# financeadmin - gives read only access and write access for billing +# read - gives read only access to the account +# metricsread - gives read only access to all namespace metrics +# Deprecated: Not supported after v0.3.0 api version. Use role instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def role_deprecated=(value) + end + + # The role on the account, should be one of [owner, admin, developer, financeadmin, read, metricsread] +# owner - gives full access to the account, including users, namespaces, and billing +# admin - gives full access the account, including users and namespaces +# developer - gives access to create namespaces on the account +# financeadmin - gives read only access and write access for billing +# read - gives read only access to the account +# metricsread - gives read only access to all namespace metrics +# Deprecated: Not supported after v0.3.0 api version. Use role instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_role_deprecated + end + + # The role on the account. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=role_deprecated + sig { returns(T.any(Symbol, Integer)) } + def role + end + + # The role on the account. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=role_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def role=(value) + end + + # The role on the account. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=role_deprecated + sig { void } + def clear_role + 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::Cloud::Identity::V1::AccountAccess) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::AccountAccess).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::AccountAccess) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::AccountAccess, 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::Cloud::Identity::V1::NamespaceAccess + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + permission_deprecated: T.nilable(String), + permission: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + permission_deprecated: "", + permission: :PERMISSION_UNSPECIFIED + ) + end + + # The permission to the namespace, should be one of [admin, write, read] +# admin - gives full access to the namespace, including assigning namespace access to other users +# write - gives write access to the namespace configuration and workflows within the namespace +# read - gives read only access to the namespace configuration and workflows within the namespace +# Deprecated: Not supported after v0.3.0 api version. Use permission instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def permission_deprecated + end + + # The permission to the namespace, should be one of [admin, write, read] +# admin - gives full access to the namespace, including assigning namespace access to other users +# write - gives write access to the namespace configuration and workflows within the namespace +# read - gives read only access to the namespace configuration and workflows within the namespace +# Deprecated: Not supported after v0.3.0 api version. Use permission instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def permission_deprecated=(value) + end + + # The permission to the namespace, should be one of [admin, write, read] +# admin - gives full access to the namespace, including assigning namespace access to other users +# write - gives write access to the namespace configuration and workflows within the namespace +# read - gives read only access to the namespace configuration and workflows within the namespace +# Deprecated: Not supported after v0.3.0 api version. Use permission instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_permission_deprecated + end + + # The permission to the namespace. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=permission_deprecated + sig { returns(T.any(Symbol, Integer)) } + def permission + end + + # The permission to the namespace. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=permission_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def permission=(value) + end + + # The permission to the namespace. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=permission_deprecated + sig { void } + def clear_permission + 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::Cloud::Identity::V1::NamespaceAccess) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::NamespaceAccess).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::NamespaceAccess, 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::Cloud::Identity::V1::Access + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + account_access: T.nilable(Temporalio::Api::Cloud::Identity::V1::AccountAccess), + namespace_accesses: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)]) + ).void + end + def initialize( + account_access: nil, + namespace_accesses: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Cloud::Identity::V1::NamespaceAccess) + ) + end + + # The account access + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::AccountAccess)) } + def account_access + end + + # The account access + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::AccountAccess)).void } + def account_access=(value) + end + + # The account access + sig { void } + def clear_account_access + end + + # The map of namespace accesses +# The key is the namespace name and the value is the access to the namespace + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)]) } + def namespace_accesses + end + + # The map of namespace accesses +# The key is the namespace name and the value is the access to the namespace + sig { params(value: ::Google::Protobuf::Map).void } + def namespace_accesses=(value) + end + + # The map of namespace accesses +# The key is the namespace name and the value is the access to the namespace + sig { void } + def clear_namespace_accesses + 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::Cloud::Identity::V1::Access) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::Access).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::Access) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::Access, 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::Cloud::Identity::V1::NamespaceScopedAccess + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + access: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess) + ).void + end + def initialize( + namespace: "", + access: nil + ) + end + + # The namespace the service account is assigned to - immutable. + sig { returns(String) } + def namespace + end + + # The namespace the service account is assigned to - immutable. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace the service account is assigned to - immutable. + sig { void } + def clear_namespace + end + + # The namespace access assigned to the service account - mutable. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)) } + def access + end + + # The namespace access assigned to the service account - mutable. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceAccess)).void } + def access=(value) + end + + # The namespace access assigned to the service account - mutable. + sig { void } + def clear_access + 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::Cloud::Identity::V1::NamespaceScopedAccess) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::NamespaceScopedAccess).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::NamespaceScopedAccess) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::NamespaceScopedAccess, 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::Cloud::Identity::V1::UserSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + email: T.nilable(String), + access: T.nilable(Temporalio::Api::Cloud::Identity::V1::Access) + ).void + end + def initialize( + email: "", + access: nil + ) + end + + # The email address associated to the user + sig { returns(String) } + def email + end + + # The email address associated to the user + sig { params(value: String).void } + def email=(value) + end + + # The email address associated to the user + sig { void } + def clear_email + end + + # The access to assigned to the user + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::Access)) } + def access + end + + # The access to assigned to the user + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::Access)).void } + def access=(value) + end + + # The access to assigned to the user + sig { void } + def clear_access + 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::Cloud::Identity::V1::UserSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::UserSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserSpec, 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::Cloud::Identity::V1::Invitation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + created_time: T.nilable(Google::Protobuf::Timestamp), + expired_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + created_time: nil, + expired_time: nil + ) + end + + # The date and time when the user was created + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the user was created + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the user was created + sig { void } + def clear_created_time + end + + # The date and time when the invitation expires or has expired + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def expired_time + end + + # The date and time when the invitation expires or has expired + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def expired_time=(value) + end + + # The date and time when the invitation expires or has expired + sig { void } + def clear_expired_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::Cloud::Identity::V1::Invitation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::Invitation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::Invitation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::Invitation, 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::Cloud::Identity::V1::User + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + resource_version: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec), + state_deprecated: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String), + invitation: T.nilable(Temporalio::Api::Cloud::Identity::V1::Invitation), + created_time: T.nilable(Google::Protobuf::Timestamp), + last_modified_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + id: "", + resource_version: "", + spec: nil, + state_deprecated: "", + state: :RESOURCE_STATE_UNSPECIFIED, + async_operation_id: "", + invitation: nil, + created_time: nil, + last_modified_time: nil + ) + end + + # The id of the user + sig { returns(String) } + def id + end + + # The id of the user + sig { params(value: String).void } + def id=(value) + end + + # The id of the user + sig { void } + def clear_id + end + + # The current version of the user specification +# The next update operation will have to include this version + sig { returns(String) } + def resource_version + end + + # The current version of the user specification +# The next update operation will have to include this version + sig { params(value: String).void } + def resource_version=(value) + end + + # The current version of the user specification +# The next update operation will have to include this version + sig { void } + def clear_resource_version + end + + # The user specification + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec)) } + def spec + end + + # The user specification + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserSpec)).void } + def spec=(value) + end + + # The user specification + sig { void } + def clear_spec + end + + # The current state of the user +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def state_deprecated + end + + # The current state of the user +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def state_deprecated=(value) + end + + # The current state of the user +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_state_deprecated + end + + # The current state of the user. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the user. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the user. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { void } + def clear_state + end + + # The id of the async operation that is creating/updating/deleting the user, if any + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is creating/updating/deleting the user, if any + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is creating/updating/deleting the user, if any + sig { void } + def clear_async_operation_id + end + + # The details of the open invitation sent to the user, if any + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::Invitation)) } + def invitation + end + + # The details of the open invitation sent to the user, if any + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::Invitation)).void } + def invitation=(value) + end + + # The details of the open invitation sent to the user, if any + sig { void } + def clear_invitation + end + + # The date and time when the user was created + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the user was created + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the user was created + sig { void } + def clear_created_time + end + + # The date and time when the user was last modified +# Will not be set if the user has never been modified + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_modified_time + end + + # The date and time when the user was last modified +# Will not be set if the user has never been modified + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_modified_time=(value) + end + + # The date and time when the user was last modified +# Will not be set if the user has never been modified + sig { void } + def clear_last_modified_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::Cloud::Identity::V1::User) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::User).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::User) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::User, 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::Cloud::Identity::V1::GoogleGroupSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + email_address: T.nilable(String) + ).void + end + def initialize( + email_address: "" + ) + end + + # The email address of the Google group. +# The email address is immutable. Once set during creation, it cannot be changed. + sig { returns(String) } + def email_address + end + + # The email address of the Google group. +# The email address is immutable. Once set during creation, it cannot be changed. + sig { params(value: String).void } + def email_address=(value) + end + + # The email address of the Google group. +# The email address is immutable. Once set during creation, it cannot be changed. + sig { void } + def clear_email_address + 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::Cloud::Identity::V1::GoogleGroupSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::GoogleGroupSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::GoogleGroupSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::GoogleGroupSpec, 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::Cloud::Identity::V1::SCIMGroupSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + idp_id: T.nilable(String) + ).void + end + def initialize( + idp_id: "" + ) + end + + # The id used in the upstream identity provider. + sig { returns(String) } + def idp_id + end + + # The id used in the upstream identity provider. + sig { params(value: String).void } + def idp_id=(value) + end + + # The id used in the upstream identity provider. + sig { void } + def clear_idp_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::Cloud::Identity::V1::SCIMGroupSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::SCIMGroupSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::SCIMGroupSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::SCIMGroupSpec, 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::Cloud::Identity::V1::CloudGroupSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::Identity::V1::CloudGroupSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::CloudGroupSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::CloudGroupSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::CloudGroupSpec, 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::Cloud::Identity::V1::UserGroupSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + display_name: T.nilable(String), + access: T.nilable(Temporalio::Api::Cloud::Identity::V1::Access), + google_group: T.nilable(Temporalio::Api::Cloud::Identity::V1::GoogleGroupSpec), + scim_group: T.nilable(Temporalio::Api::Cloud::Identity::V1::SCIMGroupSpec), + cloud_group: T.nilable(Temporalio::Api::Cloud::Identity::V1::CloudGroupSpec) + ).void + end + def initialize( + display_name: "", + access: nil, + google_group: nil, + scim_group: nil, + cloud_group: nil + ) + end + + # The display name of the group. + sig { returns(String) } + def display_name + end + + # The display name of the group. + sig { params(value: String).void } + def display_name=(value) + end + + # The display name of the group. + sig { void } + def clear_display_name + end + + # The access assigned to the group. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::Access)) } + def access + end + + # The access assigned to the group. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::Access)).void } + def access=(value) + end + + # The access assigned to the group. + sig { void } + def clear_access + end + + # The specification of the google group that this group is associated with. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::GoogleGroupSpec)) } + def google_group + end + + # The specification of the google group that this group is associated with. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::GoogleGroupSpec)).void } + def google_group=(value) + end + + # The specification of the google group that this group is associated with. + sig { void } + def clear_google_group + end + + # The specification of the SCIM group that this group is associated with. +# SCIM groups cannot be created or deleted directly, but their access can be managed. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::SCIMGroupSpec)) } + def scim_group + end + + # The specification of the SCIM group that this group is associated with. +# SCIM groups cannot be created or deleted directly, but their access can be managed. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::SCIMGroupSpec)).void } + def scim_group=(value) + end + + # The specification of the SCIM group that this group is associated with. +# SCIM groups cannot be created or deleted directly, but their access can be managed. + sig { void } + def clear_scim_group + end + + # The specification for a Cloud group. Cloud groups can manage members using +# the add and remove member APIs. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::CloudGroupSpec)) } + def cloud_group + end + + # The specification for a Cloud group. Cloud groups can manage members using +# the add and remove member APIs. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::CloudGroupSpec)).void } + def cloud_group=(value) + end + + # The specification for a Cloud group. Cloud groups can manage members using +# the add and remove member APIs. + sig { void } + def clear_cloud_group + end + + sig { returns(T.nilable(Symbol)) } + def group_type + 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::Cloud::Identity::V1::UserGroupSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserGroupSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserGroupSpec, 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::Cloud::Identity::V1::UserGroup + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + resource_version: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec), + state_deprecated: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String), + created_time: T.nilable(Google::Protobuf::Timestamp), + last_modified_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + id: "", + resource_version: "", + spec: nil, + state_deprecated: "", + state: :RESOURCE_STATE_UNSPECIFIED, + async_operation_id: "", + created_time: nil, + last_modified_time: nil + ) + end + + # The id of the group + sig { returns(String) } + def id + end + + # The id of the group + sig { params(value: String).void } + def id=(value) + end + + # The id of the group + sig { void } + def clear_id + end + + # The current version of the group specification +# The next update operation will have to include this version + sig { returns(String) } + def resource_version + end + + # The current version of the group specification +# The next update operation will have to include this version + sig { params(value: String).void } + def resource_version=(value) + end + + # The current version of the group specification +# The next update operation will have to include this version + sig { void } + def clear_resource_version + end + + # The group specification + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec)) } + def spec + end + + # The group specification + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupSpec)).void } + def spec=(value) + end + + # The group specification + sig { void } + def clear_spec + end + + # The current state of the group. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def state_deprecated + end + + # The current state of the group. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def state_deprecated=(value) + end + + # The current state of the group. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_state_deprecated + end + + # The current state of the group. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the group. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the group. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { void } + def clear_state + end + + # The id of the async operation that is creating/updating/deleting the group, if any + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is creating/updating/deleting the group, if any + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is creating/updating/deleting the group, if any + sig { void } + def clear_async_operation_id + end + + # The date and time when the group was created + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the group was created + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the group was created + sig { void } + def clear_created_time + end + + # The date and time when the group was last modified +# Will not be set if the group has never been modified + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_modified_time + end + + # The date and time when the group was last modified +# Will not be set if the group has never been modified + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_modified_time=(value) + end + + # The date and time when the group was last modified +# Will not be set if the group has never been modified + sig { void } + def clear_last_modified_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::Cloud::Identity::V1::UserGroup) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserGroup).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::UserGroup) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserGroup, 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::Cloud::Identity::V1::UserGroupMemberId + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + user_id: T.nilable(String) + ).void + end + def initialize( + user_id: "" + ) + end + + sig { returns(String) } + def user_id + end + + sig { params(value: String).void } + def user_id=(value) + end + + sig { void } + def clear_user_id + end + + sig { returns(T.nilable(Symbol)) } + def member_type + 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::Cloud::Identity::V1::UserGroupMemberId) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId, 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::Cloud::Identity::V1::UserGroupMember + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + member_id: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId), + created_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + member_id: nil, + created_time: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId)) } + def member_id + end + + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::UserGroupMemberId)).void } + def member_id=(value) + end + + sig { void } + def clear_member_id + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + sig { void } + def clear_created_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::Cloud::Identity::V1::UserGroupMember) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserGroupMember).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::UserGroupMember) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::UserGroupMember, 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::Cloud::Identity::V1::ServiceAccount + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + resource_version: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec), + state_deprecated: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String), + created_time: T.nilable(Google::Protobuf::Timestamp), + last_modified_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + id: "", + resource_version: "", + spec: nil, + state_deprecated: "", + state: :RESOURCE_STATE_UNSPECIFIED, + async_operation_id: "", + created_time: nil, + last_modified_time: nil + ) + end + + # The id of the service account. + sig { returns(String) } + def id + end + + # The id of the service account. + sig { params(value: String).void } + def id=(value) + end + + # The id of the service account. + sig { void } + def clear_id + end + + # The current version of the service account specification. +# The next update operation will have to include this version. + sig { returns(String) } + def resource_version + end + + # The current version of the service account specification. +# The next update operation will have to include this version. + sig { params(value: String).void } + def resource_version=(value) + end + + # The current version of the service account specification. +# The next update operation will have to include this version. + sig { void } + def clear_resource_version + end + + # The service account specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec)) } + def spec + end + + # The service account specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec)).void } + def spec=(value) + end + + # The service account specification. + sig { void } + def clear_spec + end + + # The current state of the service account. +# Possible values: activating, activationfailed, active, updating, updatefailed, deleting, deletefailed, deleted, suspending, suspendfailed, suspended. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def state_deprecated + end + + # The current state of the service account. +# Possible values: activating, activationfailed, active, updating, updatefailed, deleting, deletefailed, deleted, suspending, suspendfailed, suspended. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def state_deprecated=(value) + end + + # The current state of the service account. +# Possible values: activating, activationfailed, active, updating, updatefailed, deleting, deletefailed, deleted, suspending, suspendfailed, suspended. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_state_deprecated + end + + # The current state of the service account. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the service account. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the service account. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { void } + def clear_state + end + + # The id of the async operation that is creating/updating/deleting the service account, if any. + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is creating/updating/deleting the service account, if any. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is creating/updating/deleting the service account, if any. + sig { void } + def clear_async_operation_id + end + + # The date and time when the service account was created. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the service account was created. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the service account was created. + sig { void } + def clear_created_time + end + + # The date and time when the service account was last modified +# Will not be set if the service account has never been modified. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_modified_time + end + + # The date and time when the service account was last modified +# Will not be set if the service account has never been modified. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_modified_time=(value) + end + + # The date and time when the service account was last modified +# Will not be set if the service account has never been modified. + sig { void } + def clear_last_modified_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::Cloud::Identity::V1::ServiceAccount) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::ServiceAccount).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::ServiceAccount) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::ServiceAccount, 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::Cloud::Identity::V1::ServiceAccountSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + access: T.nilable(Temporalio::Api::Cloud::Identity::V1::Access), + namespace_scoped_access: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceScopedAccess), + description: T.nilable(String) + ).void + end + def initialize( + name: "", + access: nil, + namespace_scoped_access: nil, + description: "" + ) + end + + # The name associated with the service account. +# The name is mutable, but must be unique across all your active service accounts. + sig { returns(String) } + def name + end + + # The name associated with the service account. +# The name is mutable, but must be unique across all your active service accounts. + sig { params(value: String).void } + def name=(value) + end + + # The name associated with the service account. +# The name is mutable, but must be unique across all your active service accounts. + sig { void } + def clear_name + end + + # Note: one of `Access` or `NamespaceScopedAccess` must be provided, but not both. +# The access assigned to the service account. +# If set, creates an account scoped service account. +# The access is mutable. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::Access)) } + def access + end + + # Note: one of `Access` or `NamespaceScopedAccess` must be provided, but not both. +# The access assigned to the service account. +# If set, creates an account scoped service account. +# The access is mutable. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::Access)).void } + def access=(value) + end + + # Note: one of `Access` or `NamespaceScopedAccess` must be provided, but not both. +# The access assigned to the service account. +# If set, creates an account scoped service account. +# The access is mutable. + sig { void } + def clear_access + end + + # The namespace scoped access assigned to the service account. +# If set, creates a namespace scoped service account (limited to a single namespace). +# The namespace scoped access is partially mutable. +# Refer to `NamespaceScopedAccess` for details. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceScopedAccess)) } + def namespace_scoped_access + end + + # The namespace scoped access assigned to the service account. +# If set, creates a namespace scoped service account (limited to a single namespace). +# The namespace scoped access is partially mutable. +# Refer to `NamespaceScopedAccess` for details. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::NamespaceScopedAccess)).void } + def namespace_scoped_access=(value) + end + + # The namespace scoped access assigned to the service account. +# If set, creates a namespace scoped service account (limited to a single namespace). +# The namespace scoped access is partially mutable. +# Refer to `NamespaceScopedAccess` for details. + sig { void } + def clear_namespace_scoped_access + end + + # The description associated with the service account - optional. +# The description is mutable. + sig { returns(String) } + def description + end + + # The description associated with the service account - optional. +# The description is mutable. + sig { params(value: String).void } + def description=(value) + end + + # The description associated with the service account - optional. +# The description is mutable. + sig { void } + def clear_description + 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::Cloud::Identity::V1::ServiceAccountSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::ServiceAccountSpec, 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::Cloud::Identity::V1::ApiKey + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + resource_version: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec), + state_deprecated: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String), + created_time: T.nilable(Google::Protobuf::Timestamp), + last_modified_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + id: "", + resource_version: "", + spec: nil, + state_deprecated: "", + state: :RESOURCE_STATE_UNSPECIFIED, + async_operation_id: "", + created_time: nil, + last_modified_time: nil + ) + end + + # The id of the API Key. + sig { returns(String) } + def id + end + + # The id of the API Key. + sig { params(value: String).void } + def id=(value) + end + + # The id of the API Key. + sig { void } + def clear_id + end + + # The current version of the API key specification. +# The next update operation will have to include this version. + sig { returns(String) } + def resource_version + end + + # The current version of the API key specification. +# The next update operation will have to include this version. + sig { params(value: String).void } + def resource_version=(value) + end + + # The current version of the API key specification. +# The next update operation will have to include this version. + sig { void } + def clear_resource_version + end + + # The API key specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec)) } + def spec + end + + # The API key specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec)).void } + def spec=(value) + end + + # The API key specification. + sig { void } + def clear_spec + end + + # The current state of the API key. +# Possible values: activating, activationfailed, active, updating, updatefailed, deleting, deletefailed, deleted, suspending, suspendfailed, suspended. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def state_deprecated + end + + # The current state of the API key. +# Possible values: activating, activationfailed, active, updating, updatefailed, deleting, deletefailed, deleted, suspending, suspendfailed, suspended. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def state_deprecated=(value) + end + + # The current state of the API key. +# Possible values: activating, activationfailed, active, updating, updatefailed, deleting, deletefailed, deleted, suspending, suspendfailed, suspended. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_state_deprecated + end + + # The current state of the API key. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the API key. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the API key. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { void } + def clear_state + end + + # The id of the async operation that is creating/updating/deleting the API key, if any. + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is creating/updating/deleting the API key, if any. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is creating/updating/deleting the API key, if any. + sig { void } + def clear_async_operation_id + end + + # The date and time when the API key was created. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the API key was created. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the API key was created. + sig { void } + def clear_created_time + end + + # The date and time when the API key was last modified. +# Will not be set if the API key has never been modified. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_modified_time + end + + # The date and time when the API key was last modified. +# Will not be set if the API key has never been modified. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_modified_time=(value) + end + + # The date and time when the API key was last modified. +# Will not be set if the API key has never been modified. + sig { void } + def clear_last_modified_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::Cloud::Identity::V1::ApiKey) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::ApiKey).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::ApiKey) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::ApiKey, 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::Cloud::Identity::V1::ApiKeySpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + owner_id: T.nilable(String), + owner_type_deprecated: T.nilable(String), + owner_type: T.nilable(T.any(Symbol, String, Integer)), + display_name: T.nilable(String), + description: T.nilable(String), + expiry_time: T.nilable(Google::Protobuf::Timestamp), + disabled: T.nilable(T::Boolean) + ).void + end + def initialize( + owner_id: "", + owner_type_deprecated: "", + owner_type: :OWNER_TYPE_UNSPECIFIED, + display_name: "", + description: "", + expiry_time: nil, + disabled: false + ) + end + + # The id of the owner to create the API key for. +# The owner id is immutable. Once set during creation, it cannot be changed. +# The owner id is the id of the user when the owner type is user. +# The owner id is the id of the service account when the owner type is service account. + sig { returns(String) } + def owner_id + end + + # The id of the owner to create the API key for. +# The owner id is immutable. Once set during creation, it cannot be changed. +# The owner id is the id of the user when the owner type is user. +# The owner id is the id of the service account when the owner type is service account. + sig { params(value: String).void } + def owner_id=(value) + end + + # The id of the owner to create the API key for. +# The owner id is immutable. Once set during creation, it cannot be changed. +# The owner id is the id of the user when the owner type is user. +# The owner id is the id of the service account when the owner type is service account. + sig { void } + def clear_owner_id + end + + # The type of the owner to create the API key for. +# The owner type is immutable. Once set during creation, it cannot be changed. +# Possible values: user, service-account. +# Deprecated: Not supported after v0.3.0 api version. Use owner_type instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def owner_type_deprecated + end + + # The type of the owner to create the API key for. +# The owner type is immutable. Once set during creation, it cannot be changed. +# Possible values: user, service-account. +# Deprecated: Not supported after v0.3.0 api version. Use owner_type instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def owner_type_deprecated=(value) + end + + # The type of the owner to create the API key for. +# The owner type is immutable. Once set during creation, it cannot be changed. +# Possible values: user, service-account. +# Deprecated: Not supported after v0.3.0 api version. Use owner_type instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_owner_type_deprecated + end + + # The type of the owner to create the API key for. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=owner_type_deprecated + sig { returns(T.any(Symbol, Integer)) } + def owner_type + end + + # The type of the owner to create the API key for. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=owner_type_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def owner_type=(value) + end + + # The type of the owner to create the API key for. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=owner_type_deprecated + sig { void } + def clear_owner_type + end + + # The display name of the API key. + sig { returns(String) } + def display_name + end + + # The display name of the API key. + sig { params(value: String).void } + def display_name=(value) + end + + # The display name of the API key. + sig { void } + def clear_display_name + end + + # The description of the API key. + sig { returns(String) } + def description + end + + # The description of the API key. + sig { params(value: String).void } + def description=(value) + end + + # The description of the API key. + sig { void } + def clear_description + end + + # The expiry time of the API key. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def expiry_time + end + + # The expiry time of the API key. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def expiry_time=(value) + end + + # The expiry time of the API key. + sig { void } + def clear_expiry_time + end + + # True if the API key is disabled. + sig { returns(T::Boolean) } + def disabled + end + + # True if the API key is disabled. + sig { params(value: T::Boolean).void } + def disabled=(value) + end + + # True if the API key is disabled. + sig { void } + def clear_disabled + 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::Cloud::Identity::V1::ApiKeySpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::ApiKeySpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Identity::V1::ApiKeySpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Identity::V1::ApiKeySpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Identity::V1::OwnerType + self::OWNER_TYPE_UNSPECIFIED = T.let(0, Integer) + self::OWNER_TYPE_USER = T.let(1, Integer) + self::OWNER_TYPE_SERVICE_ACCOUNT = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Identity::V1::AccountAccess::Role + self::ROLE_UNSPECIFIED = T.let(0, Integer) + self::ROLE_OWNER = T.let(1, Integer) + self::ROLE_ADMIN = T.let(2, Integer) + self::ROLE_DEVELOPER = T.let(3, Integer) + self::ROLE_FINANCE_ADMIN = T.let(4, Integer) + self::ROLE_READ = T.let(5, Integer) + self::ROLE_METRICS_READ = T.let(6, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Identity::V1::NamespaceAccess::Permission + self::PERMISSION_UNSPECIFIED = T.let(0, Integer) + self::PERMISSION_ADMIN = T.let(1, Integer) + self::PERMISSION_WRITE = T.let(2, Integer) + self::PERMISSION_READ = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/namespace/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/namespace/v1/message.rbi new file mode 100644 index 00000000..29389c7e --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/namespace/v1/message.rbi @@ -0,0 +1,3278 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/namespace/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Namespace::V1::CertificateFilterSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + common_name: T.nilable(String), + organization: T.nilable(String), + organizational_unit: T.nilable(String), + subject_alternative_name: T.nilable(String) + ).void + end + def initialize( + common_name: "", + organization: "", + organizational_unit: "", + subject_alternative_name: "" + ) + end + + # The common_name in the certificate. +# Optional, default is empty. + sig { returns(String) } + def common_name + end + + # The common_name in the certificate. +# Optional, default is empty. + sig { params(value: String).void } + def common_name=(value) + end + + # The common_name in the certificate. +# Optional, default is empty. + sig { void } + def clear_common_name + end + + # The organization in the certificate. +# Optional, default is empty. + sig { returns(String) } + def organization + end + + # The organization in the certificate. +# Optional, default is empty. + sig { params(value: String).void } + def organization=(value) + end + + # The organization in the certificate. +# Optional, default is empty. + sig { void } + def clear_organization + end + + # The organizational_unit in the certificate. +# Optional, default is empty. + sig { returns(String) } + def organizational_unit + end + + # The organizational_unit in the certificate. +# Optional, default is empty. + sig { params(value: String).void } + def organizational_unit=(value) + end + + # The organizational_unit in the certificate. +# Optional, default is empty. + sig { void } + def clear_organizational_unit + end + + # The subject_alternative_name in the certificate. +# Optional, default is empty. + sig { returns(String) } + def subject_alternative_name + end + + # The subject_alternative_name in the certificate. +# Optional, default is empty. + sig { params(value: String).void } + def subject_alternative_name=(value) + end + + # The subject_alternative_name in the certificate. +# Optional, default is empty. + sig { void } + def clear_subject_alternative_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::Cloud::Namespace::V1::CertificateFilterSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CertificateFilterSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::CertificateFilterSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CertificateFilterSpec, 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::Cloud::Namespace::V1::MtlsAuthSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + accepted_client_ca_deprecated: T.nilable(String), + accepted_client_ca: T.nilable(String), + certificate_filters: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Namespace::V1::CertificateFilterSpec)]), + enabled: T.nilable(T::Boolean) + ).void + end + def initialize( + accepted_client_ca_deprecated: "", + accepted_client_ca: "", + certificate_filters: [], + enabled: false + ) + end + + # The base64 encoded ca cert(s) in PEM format that the clients can use for authentication and authorization. +# This must only be one value, but the CA can have a chain. +# +# (-- api-linter: core::0140::base64=disabled --) +# Deprecated: Not supported after v0.2.0 api version. Use accepted_client_ca instead. +# temporal:versioning:max_version=v0.2.0 + sig { returns(String) } + def accepted_client_ca_deprecated + end + + # The base64 encoded ca cert(s) in PEM format that the clients can use for authentication and authorization. +# This must only be one value, but the CA can have a chain. +# +# (-- api-linter: core::0140::base64=disabled --) +# Deprecated: Not supported after v0.2.0 api version. Use accepted_client_ca instead. +# temporal:versioning:max_version=v0.2.0 + sig { params(value: String).void } + def accepted_client_ca_deprecated=(value) + end + + # The base64 encoded ca cert(s) in PEM format that the clients can use for authentication and authorization. +# This must only be one value, but the CA can have a chain. +# +# (-- api-linter: core::0140::base64=disabled --) +# Deprecated: Not supported after v0.2.0 api version. Use accepted_client_ca instead. +# temporal:versioning:max_version=v0.2.0 + sig { void } + def clear_accepted_client_ca_deprecated + end + + # The ca cert(s) in PEM format that the clients can use for authentication and authorization. +# This must only be one value, but the CA can have a chain. +# temporal:versioning:min_version=v0.2.0 + sig { returns(String) } + def accepted_client_ca + end + + # The ca cert(s) in PEM format that the clients can use for authentication and authorization. +# This must only be one value, but the CA can have a chain. +# temporal:versioning:min_version=v0.2.0 + sig { params(value: String).void } + def accepted_client_ca=(value) + end + + # The ca cert(s) in PEM format that the clients can use for authentication and authorization. +# This must only be one value, but the CA can have a chain. +# temporal:versioning:min_version=v0.2.0 + sig { void } + def clear_accepted_client_ca + end + + # Certificate filters which, if specified, only allow connections from client certificates whose distinguished name properties match at least one of the filters. +# This allows limiting access to specific end-entity certificates. +# Optional, default is empty. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Namespace::V1::CertificateFilterSpec)]) } + def certificate_filters + end + + # Certificate filters which, if specified, only allow connections from client certificates whose distinguished name properties match at least one of the filters. +# This allows limiting access to specific end-entity certificates. +# Optional, default is empty. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def certificate_filters=(value) + end + + # Certificate filters which, if specified, only allow connections from client certificates whose distinguished name properties match at least one of the filters. +# This allows limiting access to specific end-entity certificates. +# Optional, default is empty. + sig { void } + def clear_certificate_filters + end + + # Flag to enable mTLS auth (default: disabled). +# Note: disabling mTLS auth will cause existing mTLS connections to fail. +# temporal:versioning:min_version=v0.2.0 + sig { returns(T::Boolean) } + def enabled + end + + # Flag to enable mTLS auth (default: disabled). +# Note: disabling mTLS auth will cause existing mTLS connections to fail. +# temporal:versioning:min_version=v0.2.0 + sig { params(value: T::Boolean).void } + def enabled=(value) + end + + # Flag to enable mTLS auth (default: disabled). +# Note: disabling mTLS auth will cause existing mTLS connections to fail. +# temporal:versioning:min_version=v0.2.0 + sig { void } + def clear_enabled + 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::Cloud::Namespace::V1::MtlsAuthSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::MtlsAuthSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::MtlsAuthSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::MtlsAuthSpec, 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::Cloud::Namespace::V1::ApiKeyAuthSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + enabled: T.nilable(T::Boolean) + ).void + end + def initialize( + enabled: false + ) + end + + # Flag to enable API key auth (default: disabled). +# Note: disabling API key auth will cause existing API key connections to fail. + sig { returns(T::Boolean) } + def enabled + end + + # Flag to enable API key auth (default: disabled). +# Note: disabling API key auth will cause existing API key connections to fail. + sig { params(value: T::Boolean).void } + def enabled=(value) + end + + # Flag to enable API key auth (default: disabled). +# Note: disabling API key auth will cause existing API key connections to fail. + sig { void } + def clear_enabled + 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::Cloud::Namespace::V1::ApiKeyAuthSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::ApiKeyAuthSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::ApiKeyAuthSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::ApiKeyAuthSpec, 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::Cloud::Namespace::V1::LifecycleSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + enable_delete_protection: T.nilable(T::Boolean) + ).void + end + def initialize( + enable_delete_protection: false + ) + end + + # Flag to enable delete protection for the namespace. + sig { returns(T::Boolean) } + def enable_delete_protection + end + + # Flag to enable delete protection for the namespace. + sig { params(value: T::Boolean).void } + def enable_delete_protection=(value) + end + + # Flag to enable delete protection for the namespace. + sig { void } + def clear_enable_delete_protection + 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::Cloud::Namespace::V1::LifecycleSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::LifecycleSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::LifecycleSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::LifecycleSpec, 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::Cloud::Namespace::V1::CodecServerSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint: T.nilable(String), + pass_access_token: T.nilable(T::Boolean), + include_cross_origin_credentials: T.nilable(T::Boolean), + custom_error_message: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage) + ).void + end + def initialize( + endpoint: "", + pass_access_token: false, + include_cross_origin_credentials: false, + custom_error_message: nil + ) + end + + # The codec server endpoint. + sig { returns(String) } + def endpoint + end + + # The codec server endpoint. + sig { params(value: String).void } + def endpoint=(value) + end + + # The codec server endpoint. + sig { void } + def clear_endpoint + end + + # Whether to pass the user access token with your endpoint. + sig { returns(T::Boolean) } + def pass_access_token + end + + # Whether to pass the user access token with your endpoint. + sig { params(value: T::Boolean).void } + def pass_access_token=(value) + end + + # Whether to pass the user access token with your endpoint. + sig { void } + def clear_pass_access_token + end + + # Whether to include cross-origin credentials. + sig { returns(T::Boolean) } + def include_cross_origin_credentials + end + + # Whether to include cross-origin credentials. + sig { params(value: T::Boolean).void } + def include_cross_origin_credentials=(value) + end + + # Whether to include cross-origin credentials. + sig { void } + def clear_include_cross_origin_credentials + end + + # A custom error message to display for remote codec server errors. +# temporal:versioning:min_version=v0.5.1 + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage)) } + def custom_error_message + end + + # A custom error message to display for remote codec server errors. +# temporal:versioning:min_version=v0.5.1 + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage)).void } + def custom_error_message=(value) + end + + # A custom error message to display for remote codec server errors. +# temporal:versioning:min_version=v0.5.1 + sig { void } + def clear_custom_error_message + 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::Cloud::Namespace::V1::CodecServerSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec, 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::Cloud::Namespace::V1::HighAvailabilitySpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + disable_managed_failover: T.nilable(T::Boolean) + ).void + end + def initialize( + disable_managed_failover: false + ) + end + + # Flag to disable managed failover for the namespace. + sig { returns(T::Boolean) } + def disable_managed_failover + end + + # Flag to disable managed failover for the namespace. + sig { params(value: T::Boolean).void } + def disable_managed_failover=(value) + end + + # Flag to disable managed failover for the namespace. + sig { void } + def clear_disable_managed_failover + 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::Cloud::Namespace::V1::HighAvailabilitySpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::HighAvailabilitySpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::HighAvailabilitySpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::HighAvailabilitySpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# temporal:versioning:min_version=v0.10.0 +class Temporalio::Api::Cloud::Namespace::V1::CapacitySpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + on_demand: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::OnDemand), + provisioned: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::Provisioned) + ).void + end + def initialize( + on_demand: nil, + provisioned: nil + ) + end + + # The on-demand capacity mode configuration. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::OnDemand)) } + def on_demand + end + + # The on-demand capacity mode configuration. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::OnDemand)).void } + def on_demand=(value) + end + + # The on-demand capacity mode configuration. + sig { void } + def clear_on_demand + end + + # The provisioned capacity mode configuration. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::Provisioned)) } + def provisioned + end + + # The provisioned capacity mode configuration. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::Provisioned)).void } + def provisioned=(value) + end + + # The provisioned capacity mode configuration. + sig { void } + def clear_provisioned + end + + sig { returns(T.nilable(Symbol)) } + def spec + 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::Cloud::Namespace::V1::CapacitySpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CapacitySpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CapacitySpec, 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::Cloud::Namespace::V1::Capacity + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + on_demand: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::OnDemand), + provisioned: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::Provisioned), + latest_request: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::Request) + ).void + end + def initialize( + on_demand: nil, + provisioned: nil, + latest_request: nil + ) + end + + # The status of on-demand capacity mode. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::OnDemand)) } + def on_demand + end + + # The status of on-demand capacity mode. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::OnDemand)).void } + def on_demand=(value) + end + + # The status of on-demand capacity mode. + sig { void } + def clear_on_demand + end + + # The status of provisioned capacity mode. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::Provisioned)) } + def provisioned + end + + # The status of provisioned capacity mode. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::Provisioned)).void } + def provisioned=(value) + end + + # The status of provisioned capacity mode. + sig { void } + def clear_provisioned + end + + # The latest requested capacity for the namespace, if any. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::Request)) } + def latest_request + end + + # The latest requested capacity for the namespace, if any. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity::Request)).void } + def latest_request=(value) + end + + # The latest requested capacity for the namespace, if any. + sig { void } + def clear_latest_request + end + + sig { returns(T.nilable(Symbol)) } + def current_mode + 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::Cloud::Namespace::V1::Capacity) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Capacity).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::Capacity) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Capacity, 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::Cloud::Namespace::V1::NamespaceSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + regions: T.nilable(T::Array[String]), + retention_days: T.nilable(Integer), + mtls_auth: T.nilable(Temporalio::Api::Cloud::Namespace::V1::MtlsAuthSpec), + api_key_auth: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ApiKeyAuthSpec), + custom_search_attributes: T.nilable(T::Hash[String, String]), + search_attributes: T.nilable(T::Hash[String, T.any(Symbol, String, Integer)]), + codec_server: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec), + lifecycle: T.nilable(Temporalio::Api::Cloud::Namespace::V1::LifecycleSpec), + high_availability: T.nilable(Temporalio::Api::Cloud::Namespace::V1::HighAvailabilitySpec), + connectivity_rule_ids: T.nilable(T::Array[String]), + capacity_spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec) + ).void + end + def initialize( + name: "", + regions: [], + retention_days: 0, + mtls_auth: nil, + api_key_auth: nil, + custom_search_attributes: ::Google::Protobuf::Map.new(:string, :string), + search_attributes: ::Google::Protobuf::Map.new(:string, :enum), + codec_server: nil, + lifecycle: nil, + high_availability: nil, + connectivity_rule_ids: [], + capacity_spec: nil + ) + end + + # The name to use for the namespace. +# This will create a namespace that's available at '..tmprl.cloud:7233'. +# The name is immutable. Once set, it cannot be changed. + sig { returns(String) } + def name + end + + # The name to use for the namespace. +# This will create a namespace that's available at '..tmprl.cloud:7233'. +# The name is immutable. Once set, it cannot be changed. + sig { params(value: String).void } + def name=(value) + end + + # The name to use for the namespace. +# This will create a namespace that's available at '..tmprl.cloud:7233'. +# The name is immutable. Once set, it cannot be changed. + sig { void } + def clear_name + end + + # The ids of the regions where the namespace should be available. +# The GetRegions API can be used to get the list of valid region ids. +# Specifying more than one region makes the namespace "global", which is currently a preview only feature with restricted access. +# Please reach out to Temporal support for more information on global namespaces. +# When provisioned the global namespace will be active on the first region in the list and passive on the rest. +# Number of supported regions is 2. +# The regions is immutable. Once set, it cannot be changed. +# Example: ["aws-us-west-2"]. + sig { returns(T::Array[String]) } + def regions + end + + # The ids of the regions where the namespace should be available. +# The GetRegions API can be used to get the list of valid region ids. +# Specifying more than one region makes the namespace "global", which is currently a preview only feature with restricted access. +# Please reach out to Temporal support for more information on global namespaces. +# When provisioned the global namespace will be active on the first region in the list and passive on the rest. +# Number of supported regions is 2. +# The regions is immutable. Once set, it cannot be changed. +# Example: ["aws-us-west-2"]. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def regions=(value) + end + + # The ids of the regions where the namespace should be available. +# The GetRegions API can be used to get the list of valid region ids. +# Specifying more than one region makes the namespace "global", which is currently a preview only feature with restricted access. +# Please reach out to Temporal support for more information on global namespaces. +# When provisioned the global namespace will be active on the first region in the list and passive on the rest. +# Number of supported regions is 2. +# The regions is immutable. Once set, it cannot be changed. +# Example: ["aws-us-west-2"]. + sig { void } + def clear_regions + end + + # The number of days the workflows data will be retained for. +# Changes to the retention period may impact your storage costs. +# Any changes to the retention period will be applied to all new running workflows. + sig { returns(Integer) } + def retention_days + end + + # The number of days the workflows data will be retained for. +# Changes to the retention period may impact your storage costs. +# Any changes to the retention period will be applied to all new running workflows. + sig { params(value: Integer).void } + def retention_days=(value) + end + + # The number of days the workflows data will be retained for. +# Changes to the retention period may impact your storage costs. +# Any changes to the retention period will be applied to all new running workflows. + sig { void } + def clear_retention_days + end + + # The mTLS auth configuration for the namespace. +# If unspecified, mTLS will be disabled. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::MtlsAuthSpec)) } + def mtls_auth + end + + # The mTLS auth configuration for the namespace. +# If unspecified, mTLS will be disabled. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::MtlsAuthSpec)).void } + def mtls_auth=(value) + end + + # The mTLS auth configuration for the namespace. +# If unspecified, mTLS will be disabled. + sig { void } + def clear_mtls_auth + end + + # The API key auth configuration for the namespace. +# If unspecified, API keys will be disabled. +# temporal:versioning:min_version=v0.2.0 + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::ApiKeyAuthSpec)) } + def api_key_auth + end + + # The API key auth configuration for the namespace. +# If unspecified, API keys will be disabled. +# temporal:versioning:min_version=v0.2.0 + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ApiKeyAuthSpec)).void } + def api_key_auth=(value) + end + + # The API key auth configuration for the namespace. +# If unspecified, API keys will be disabled. +# temporal:versioning:min_version=v0.2.0 + sig { void } + def clear_api_key_auth + end + + # The custom search attributes to use for the namespace. +# The name of the attribute is the key and the type is the value. +# Supported attribute types: text, keyword, int, double, bool, datetime, keyword_list. +# NOTE: currently deleting a search attribute is not supported. +# Optional, default is empty. +# Deprecated: Not supported after v0.3.0 api version. Use search_attributes instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(T::Hash[String, String]) } + def custom_search_attributes + end + + # The custom search attributes to use for the namespace. +# The name of the attribute is the key and the type is the value. +# Supported attribute types: text, keyword, int, double, bool, datetime, keyword_list. +# NOTE: currently deleting a search attribute is not supported. +# Optional, default is empty. +# Deprecated: Not supported after v0.3.0 api version. Use search_attributes instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: ::Google::Protobuf::Map).void } + def custom_search_attributes=(value) + end + + # The custom search attributes to use for the namespace. +# The name of the attribute is the key and the type is the value. +# Supported attribute types: text, keyword, int, double, bool, datetime, keyword_list. +# NOTE: currently deleting a search attribute is not supported. +# Optional, default is empty. +# Deprecated: Not supported after v0.3.0 api version. Use search_attributes instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_custom_search_attributes + end + + # The custom search attributes to use for the namespace. +# The name of the attribute is the key and the type is the value. +# Note: currently deleting a search attribute is not supported. +# Optional, default is empty. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=custom_search_attributes + sig { returns(T::Hash[String, T.any(Symbol, Integer)]) } + def search_attributes + end + + # The custom search attributes to use for the namespace. +# The name of the attribute is the key and the type is the value. +# Note: currently deleting a search attribute is not supported. +# Optional, default is empty. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=custom_search_attributes + sig { params(value: ::Google::Protobuf::Map).void } + def search_attributes=(value) + end + + # The custom search attributes to use for the namespace. +# The name of the attribute is the key and the type is the value. +# Note: currently deleting a search attribute is not supported. +# Optional, default is empty. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=custom_search_attributes + sig { void } + def clear_search_attributes + end + + # Codec server spec used by UI to decode payloads for all users interacting with this namespace. +# Optional, default is unset. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec)) } + def codec_server + end + + # Codec server spec used by UI to decode payloads for all users interacting with this namespace. +# Optional, default is unset. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec)).void } + def codec_server=(value) + end + + # Codec server spec used by UI to decode payloads for all users interacting with this namespace. +# Optional, default is unset. + sig { void } + def clear_codec_server + end + + # The lifecycle configuration for the namespace. +# temporal:versioning:min_version=v0.4.0 + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::LifecycleSpec)) } + def lifecycle + end + + # The lifecycle configuration for the namespace. +# temporal:versioning:min_version=v0.4.0 + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::LifecycleSpec)).void } + def lifecycle=(value) + end + + # The lifecycle configuration for the namespace. +# temporal:versioning:min_version=v0.4.0 + sig { void } + def clear_lifecycle + end + + # The high availability configuration for the namespace. +# temporal:versioning:min_version=v0.4.0 + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::HighAvailabilitySpec)) } + def high_availability + end + + # The high availability configuration for the namespace. +# temporal:versioning:min_version=v0.4.0 + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::HighAvailabilitySpec)).void } + def high_availability=(value) + end + + # The high availability configuration for the namespace. +# temporal:versioning:min_version=v0.4.0 + sig { void } + def clear_high_availability + end + + # The private connectivity configuration for the namespace. +# This will apply the connectivity rules specified to the namespace. +# temporal:versioning:min_version=v0.6.0 + sig { returns(T::Array[String]) } + def connectivity_rule_ids + end + + # The private connectivity configuration for the namespace. +# This will apply the connectivity rules specified to the namespace. +# temporal:versioning:min_version=v0.6.0 + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def connectivity_rule_ids=(value) + end + + # The private connectivity configuration for the namespace. +# This will apply the connectivity rules specified to the namespace. +# temporal:versioning:min_version=v0.6.0 + sig { void } + def clear_connectivity_rule_ids + end + + # The capacity configuration for the namespace. +# There are two capacity modes: on-demand and provisioned. +# On-demand capacity mode allows the namespace to scale automatically based on usage. +# Provisioned capacity mode allows the user to specify a fixed amount of capacity (in TRUs) for the namespace. +# Can be changed only when the last capacity request is not in progress. +# temporal:versioning:min_version=v0.10.0 + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec)) } + def capacity_spec + end + + # The capacity configuration for the namespace. +# There are two capacity modes: on-demand and provisioned. +# On-demand capacity mode allows the namespace to scale automatically based on usage. +# Provisioned capacity mode allows the user to specify a fixed amount of capacity (in TRUs) for the namespace. +# Can be changed only when the last capacity request is not in progress. +# temporal:versioning:min_version=v0.10.0 + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec)).void } + def capacity_spec=(value) + end + + # The capacity configuration for the namespace. +# There are two capacity modes: on-demand and provisioned. +# On-demand capacity mode allows the namespace to scale automatically based on usage. +# Provisioned capacity mode allows the user to specify a fixed amount of capacity (in TRUs) for the namespace. +# Can be changed only when the last capacity request is not in progress. +# temporal:versioning:min_version=v0.10.0 + sig { void } + def clear_capacity_spec + 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::Cloud::Namespace::V1::NamespaceSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec, 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::Cloud::Namespace::V1::Endpoints + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + web_address: T.nilable(String), + mtls_grpc_address: T.nilable(String), + grpc_address: T.nilable(String) + ).void + end + def initialize( + web_address: "", + mtls_grpc_address: "", + grpc_address: "" + ) + end + + # The web UI address. + sig { returns(String) } + def web_address + end + + # The web UI address. + sig { params(value: String).void } + def web_address=(value) + end + + # The web UI address. + sig { void } + def clear_web_address + end + + # The gRPC address for mTLS client connections (may be empty if mTLS is disabled). + sig { returns(String) } + def mtls_grpc_address + end + + # The gRPC address for mTLS client connections (may be empty if mTLS is disabled). + sig { params(value: String).void } + def mtls_grpc_address=(value) + end + + # The gRPC address for mTLS client connections (may be empty if mTLS is disabled). + sig { void } + def clear_mtls_grpc_address + end + + # The gRPC address for API key client connections (may be empty if API keys are disabled). + sig { returns(String) } + def grpc_address + end + + # The gRPC address for API key client connections (may be empty if API keys are disabled). + sig { params(value: String).void } + def grpc_address=(value) + end + + # The gRPC address for API key client connections (may be empty if API keys are disabled). + sig { void } + def clear_grpc_address + 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::Cloud::Namespace::V1::Endpoints) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Endpoints).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::Endpoints) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Endpoints, 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::Cloud::Namespace::V1::Limits + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + actions_per_second_limit: T.nilable(Integer) + ).void + end + def initialize( + actions_per_second_limit: 0 + ) + end + + # The number of actions per second (APS) that is currently allowed for the namespace. +# The namespace may be throttled if its APS exceeds the limit. + sig { returns(Integer) } + def actions_per_second_limit + end + + # The number of actions per second (APS) that is currently allowed for the namespace. +# The namespace may be throttled if its APS exceeds the limit. + sig { params(value: Integer).void } + def actions_per_second_limit=(value) + end + + # The number of actions per second (APS) that is currently allowed for the namespace. +# The namespace may be throttled if its APS exceeds the limit. + sig { void } + def clear_actions_per_second_limit + 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::Cloud::Namespace::V1::Limits) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Limits).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::Limits) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Limits, 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::Cloud::Namespace::V1::AWSPrivateLinkInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + allowed_principal_arns: T.nilable(T::Array[String]), + vpc_endpoint_service_names: T.nilable(T::Array[String]) + ).void + end + def initialize( + allowed_principal_arns: [], + vpc_endpoint_service_names: [] + ) + end + + # The list of principal arns that are allowed to access the namespace on the private link. + sig { returns(T::Array[String]) } + def allowed_principal_arns + end + + # The list of principal arns that are allowed to access the namespace on the private link. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def allowed_principal_arns=(value) + end + + # The list of principal arns that are allowed to access the namespace on the private link. + sig { void } + def clear_allowed_principal_arns + end + + # The list of vpc endpoint service names that are associated with the namespace. + sig { returns(T::Array[String]) } + def vpc_endpoint_service_names + end + + # The list of vpc endpoint service names that are associated with the namespace. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def vpc_endpoint_service_names=(value) + end + + # The list of vpc endpoint service names that are associated with the namespace. + sig { void } + def clear_vpc_endpoint_service_names + 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::Cloud::Namespace::V1::AWSPrivateLinkInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::AWSPrivateLinkInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::AWSPrivateLinkInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::AWSPrivateLinkInfo, 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::Cloud::Namespace::V1::PrivateConnectivity + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + region: T.nilable(String), + aws_private_link: T.nilable(Temporalio::Api::Cloud::Namespace::V1::AWSPrivateLinkInfo) + ).void + end + def initialize( + region: "", + aws_private_link: nil + ) + end + + # The id of the region where the private connectivity applies. + sig { returns(String) } + def region + end + + # The id of the region where the private connectivity applies. + sig { params(value: String).void } + def region=(value) + end + + # The id of the region where the private connectivity applies. + sig { void } + def clear_region + end + + # The AWS PrivateLink info. +# This will only be set for an aws region. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::AWSPrivateLinkInfo)) } + def aws_private_link + end + + # The AWS PrivateLink info. +# This will only be set for an aws region. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::AWSPrivateLinkInfo)).void } + def aws_private_link=(value) + end + + # The AWS PrivateLink info. +# This will only be set for an aws region. + sig { void } + def clear_aws_private_link + 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::Cloud::Namespace::V1::PrivateConnectivity) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::PrivateConnectivity).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::PrivateConnectivity) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::PrivateConnectivity, 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::Cloud::Namespace::V1::Namespace + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + resource_version: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec), + state_deprecated: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String), + endpoints: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Endpoints), + active_region: T.nilable(String), + limits: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Limits), + private_connectivities: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Namespace::V1::PrivateConnectivity)]), + created_time: T.nilable(Google::Protobuf::Timestamp), + last_modified_time: T.nilable(Google::Protobuf::Timestamp), + region_status: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceRegionStatus)]), + connectivity_rules: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule)]), + tags: T.nilable(T::Hash[String, String]), + capacity: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity) + ).void + end + def initialize( + namespace: "", + resource_version: "", + spec: nil, + state_deprecated: "", + state: :RESOURCE_STATE_UNSPECIFIED, + async_operation_id: "", + endpoints: nil, + active_region: "", + limits: nil, + private_connectivities: [], + created_time: nil, + last_modified_time: nil, + region_status: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Cloud::Namespace::V1::NamespaceRegionStatus), + connectivity_rules: [], + tags: ::Google::Protobuf::Map.new(:string, :string), + capacity: nil + ) + end + + # The namespace identifier. + sig { returns(String) } + def namespace + end + + # The namespace identifier. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace identifier. + sig { void } + def clear_namespace + end + + # The current version of the namespace specification. +# The next update operation will have to include this version. + sig { returns(String) } + def resource_version + end + + # The current version of the namespace specification. +# The next update operation will have to include this version. + sig { params(value: String).void } + def resource_version=(value) + end + + # The current version of the namespace specification. +# The next update operation will have to include this version. + sig { void } + def clear_resource_version + end + + # The namespace specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec)) } + def spec + end + + # The namespace specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec)).void } + def spec=(value) + end + + # The namespace specification. + sig { void } + def clear_spec + end + + # The current state of the namespace. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def state_deprecated + end + + # The current state of the namespace. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def state_deprecated=(value) + end + + # The current state of the namespace. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_state_deprecated + end + + # The current state of the namespace. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the namespace. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the namespace. +# For any failed state, reach out to Temporal Cloud support for remediation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { void } + def clear_state + end + + # The id of the async operation that is creating/updating/deleting the namespace, if any. + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is creating/updating/deleting the namespace, if any. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is creating/updating/deleting the namespace, if any. + sig { void } + def clear_async_operation_id + end + + # The endpoints for the namespace. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::Endpoints)) } + def endpoints + end + + # The endpoints for the namespace. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Endpoints)).void } + def endpoints=(value) + end + + # The endpoints for the namespace. + sig { void } + def clear_endpoints + end + + # The currently active region for the namespace. + sig { returns(String) } + def active_region + end + + # The currently active region for the namespace. + sig { params(value: String).void } + def active_region=(value) + end + + # The currently active region for the namespace. + sig { void } + def clear_active_region + end + + # The limits set on the namespace currently. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::Limits)) } + def limits + end + + # The limits set on the namespace currently. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Limits)).void } + def limits=(value) + end + + # The limits set on the namespace currently. + sig { void } + def clear_limits + end + + # The private connectivities for the namespace, if any. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Namespace::V1::PrivateConnectivity)]) } + def private_connectivities + end + + # The private connectivities for the namespace, if any. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def private_connectivities=(value) + end + + # The private connectivities for the namespace, if any. + sig { void } + def clear_private_connectivities + end + + # The date and time when the namespace was created. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the namespace was created. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the namespace was created. + sig { void } + def clear_created_time + end + + # The date and time when the namespace was last modified. +# Will not be set if the namespace has never been modified. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_modified_time + end + + # The date and time when the namespace was last modified. +# Will not be set if the namespace has never been modified. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_modified_time=(value) + end + + # The date and time when the namespace was last modified. +# Will not be set if the namespace has never been modified. + sig { void } + def clear_last_modified_time + end + + # The status of each region where the namespace is available. +# The id of the region is the key and the status is the value of the map. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceRegionStatus)]) } + def region_status + end + + # The status of each region where the namespace is available. +# The id of the region is the key and the status is the value of the map. + sig { params(value: ::Google::Protobuf::Map).void } + def region_status=(value) + end + + # The status of each region where the namespace is available. +# The id of the region is the key and the status is the value of the map. + sig { void } + def clear_region_status + end + + # The connectivity rules that are set on this namespace. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::ConnectivityRule::V1::ConnectivityRule)]) } + def connectivity_rules + end + + # The connectivity rules that are set on this namespace. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def connectivity_rules=(value) + end + + # The connectivity rules that are set on this namespace. + sig { void } + def clear_connectivity_rules + end + + # The tags for the namespace. + sig { returns(T::Hash[String, String]) } + def tags + end + + # The tags for the namespace. + sig { params(value: ::Google::Protobuf::Map).void } + def tags=(value) + end + + # The tags for the namespace. + sig { void } + def clear_tags + end + + # The status of namespace's capacity, if any. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity)) } + def capacity + end + + # The status of namespace's capacity, if any. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity)).void } + def capacity=(value) + end + + # The status of namespace's capacity, if any. + sig { void } + def clear_capacity + 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::Cloud::Namespace::V1::Namespace) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Namespace).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::Namespace) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Namespace, 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::Cloud::Namespace::V1::NamespaceRegionStatus + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + state_deprecated: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String) + ).void + end + def initialize( + state_deprecated: "", + state: :STATE_UNSPECIFIED, + async_operation_id: "" + ) + end + + # The current state of the namespace region. +# Possible values: adding, active, passive, removing, failed. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def state_deprecated + end + + # The current state of the namespace region. +# Possible values: adding, active, passive, removing, failed. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def state_deprecated=(value) + end + + # The current state of the namespace region. +# Possible values: adding, active, passive, removing, failed. +# For any failed state, reach out to Temporal Cloud support for remediation. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_state_deprecated + end + + # The current state of the namespace region. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the namespace region. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the namespace region. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { void } + def clear_state + end + + # The id of the async operation that is making changes to where the namespace is available, if any. + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is making changes to where the namespace is available, if any. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is making changes to where the namespace is available, if any. + sig { void } + def clear_async_operation_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::Cloud::Namespace::V1::NamespaceRegionStatus) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceRegionStatus).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::NamespaceRegionStatus) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceRegionStatus, 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::Cloud::Namespace::V1::ExportSinkSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + enabled: T.nilable(T::Boolean), + s3: T.nilable(Temporalio::Api::Cloud::Sink::V1::S3Spec), + gcs: T.nilable(Temporalio::Api::Cloud::Sink::V1::GCSSpec) + ).void + end + def initialize( + name: "", + enabled: false, + s3: nil, + gcs: nil + ) + end + + # The unique name of the export sink, it can't be changed once set. + sig { returns(String) } + def name + end + + # The unique name of the export sink, it can't be changed once set. + sig { params(value: String).void } + def name=(value) + end + + # The unique name of the export sink, it can't be changed once set. + sig { void } + def clear_name + end + + # A flag indicating whether the export sink is enabled or not. + sig { returns(T::Boolean) } + def enabled + end + + # A flag indicating whether the export sink is enabled or not. + sig { params(value: T::Boolean).void } + def enabled=(value) + end + + # A flag indicating whether the export sink is enabled or not. + sig { void } + def clear_enabled + end + + # The S3 configuration details when destination_type is S3. + sig { returns(T.nilable(Temporalio::Api::Cloud::Sink::V1::S3Spec)) } + def s3 + end + + # The S3 configuration details when destination_type is S3. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Sink::V1::S3Spec)).void } + def s3=(value) + end + + # The S3 configuration details when destination_type is S3. + sig { void } + def clear_s3 + end + + # This is a feature under development. We will allow GCS sink support for GCP Namespaces. +# The GCS configuration details when destination_type is GCS. + sig { returns(T.nilable(Temporalio::Api::Cloud::Sink::V1::GCSSpec)) } + def gcs + end + + # This is a feature under development. We will allow GCS sink support for GCP Namespaces. +# The GCS configuration details when destination_type is GCS. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Sink::V1::GCSSpec)).void } + def gcs=(value) + end + + # This is a feature under development. We will allow GCS sink support for GCP Namespaces. +# The GCS configuration details when destination_type is GCS. + sig { void } + def clear_gcs + 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::Cloud::Namespace::V1::ExportSinkSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec, 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::Cloud::Namespace::V1::ExportSink + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + resource_version: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec), + health: T.nilable(T.any(Symbol, String, Integer)), + error_message: T.nilable(String), + latest_data_export_time: T.nilable(Google::Protobuf::Timestamp), + last_health_check_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + name: "", + resource_version: "", + state: :RESOURCE_STATE_UNSPECIFIED, + spec: nil, + health: :HEALTH_UNSPECIFIED, + error_message: "", + latest_data_export_time: nil, + last_health_check_time: nil + ) + end + + # The unique name of the export sink, once set it can't be changed + sig { returns(String) } + def name + end + + # The unique name of the export sink, once set it can't be changed + sig { params(value: String).void } + def name=(value) + end + + # The unique name of the export sink, once set it can't be changed + sig { void } + def clear_name + end + + # The version of the export sink resource. + sig { returns(String) } + def resource_version + end + + # The version of the export sink resource. + sig { params(value: String).void } + def resource_version=(value) + end + + # The version of the export sink resource. + sig { void } + def clear_resource_version + end + + # The current state of the export sink. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the export sink. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the export sink. + sig { void } + def clear_state + end + + # The specification details of the export sink. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec)) } + def spec + end + + # The specification details of the export sink. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::ExportSinkSpec)).void } + def spec=(value) + end + + # The specification details of the export sink. + sig { void } + def clear_spec + end + + # The health status of the export sink. + sig { returns(T.any(Symbol, Integer)) } + def health + end + + # The health status of the export sink. + sig { params(value: T.any(Symbol, String, Integer)).void } + def health=(value) + end + + # The health status of the export sink. + sig { void } + def clear_health + end + + # An error message describing any issues with the export sink, if applicable. + sig { returns(String) } + def error_message + end + + # An error message describing any issues with the export sink, if applicable. + sig { params(value: String).void } + def error_message=(value) + end + + # An error message describing any issues with the export sink, if applicable. + sig { void } + def clear_error_message + end + + # The timestamp of the latest successful data export. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def latest_data_export_time + end + + # The timestamp of the latest successful data export. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def latest_data_export_time=(value) + end + + # The timestamp of the latest successful data export. + sig { void } + def clear_latest_data_export_time + end + + # The timestamp of the last health check performed on the export sink. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_health_check_time + end + + # The timestamp of the last health check performed on the export sink. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_health_check_time=(value) + end + + # The timestamp of the last health check performed on the export sink. + sig { void } + def clear_last_health_check_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::Cloud::Namespace::V1::ExportSink) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::ExportSink).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::ExportSink) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::ExportSink, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# NamespaceCapacityInfo contains detailed capacity information for a namespace. +class Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + has_legacy_limits: T.nilable(T::Boolean), + current_capacity: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity), + mode_options: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions), + stats: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats) + ).void + end + def initialize( + namespace: "", + has_legacy_limits: false, + current_capacity: nil, + mode_options: nil, + stats: nil + ) + end + + # The namespace identifier. + sig { returns(String) } + def namespace + end + + # The namespace identifier. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace identifier. + sig { void } + def clear_namespace + end + + # Whether the namespace's APS limit was set by Temporal Support. +# When true, adjusting the namespace's capacity will reset this limit. + sig { returns(T::Boolean) } + def has_legacy_limits + end + + # Whether the namespace's APS limit was set by Temporal Support. +# When true, adjusting the namespace's capacity will reset this limit. + sig { params(value: T::Boolean).void } + def has_legacy_limits=(value) + end + + # Whether the namespace's APS limit was set by Temporal Support. +# When true, adjusting the namespace's capacity will reset this limit. + sig { void } + def clear_has_legacy_limits + end + + # The current capacity of the namespace. +# Includes the current mode (on-demand or provisioned) and latest request status. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity)) } + def current_capacity + end + + # The current capacity of the namespace. +# Includes the current mode (on-demand or provisioned) and latest request status. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::Capacity)).void } + def current_capacity=(value) + end + + # The current capacity of the namespace. +# Includes the current mode (on-demand or provisioned) and latest request status. + sig { void } + def clear_current_capacity + end + + # Available capacity mode options for this namespace. +# Contains configuration limits for both provisioned and on-demand modes. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions)) } + def mode_options + end + + # Available capacity mode options for this namespace. +# Contains configuration limits for both provisioned and on-demand modes. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions)).void } + def mode_options=(value) + end + + # Available capacity mode options for this namespace. +# Contains configuration limits for both provisioned and on-demand modes. + sig { void } + def clear_mode_options + end + + # Usage statistics for the namespace over the last 7 days. +# Used to calculate On-Demand capacity limits, also useful for capacity planning. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats)) } + def stats + end + + # Usage statistics for the namespace over the last 7 days. +# Used to calculate On-Demand capacity limits, also useful for capacity planning. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats)).void } + def stats=(value) + end + + # Usage statistics for the namespace over the last 7 days. +# Used to calculate On-Demand capacity limits, also useful for capacity planning. + 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::Cloud::Namespace::V1::NamespaceCapacityInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo, 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::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + default: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage::ErrorMessage) + ).void + end + def initialize( + default: nil + ) + end + + # The error message to display by default for any remote codec server errors. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage::ErrorMessage)) } + def default + end + + # The error message to display by default for any remote codec server errors. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage::ErrorMessage)).void } + def default=(value) + end + + # The error message to display by default for any remote codec server errors. + sig { void } + def clear_default + 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::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage, 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::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage::ErrorMessage + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + message: T.nilable(String), + link: T.nilable(String) + ).void + end + def initialize( + message: "", + link: "" + ) + end + + # A message to display. + sig { returns(String) } + def message + end + + # A message to display. + sig { params(value: String).void } + def message=(value) + end + + # A message to display. + sig { void } + def clear_message + end + + # A link that is displayed along side the configured message. + sig { returns(String) } + def link + end + + # A link that is displayed along side the configured message. + sig { params(value: String).void } + def link=(value) + end + + # A link that is displayed along side the configured message. + sig { void } + def clear_link + 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::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage::ErrorMessage) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage::ErrorMessage).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage::ErrorMessage) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CodecServerSpec::CustomErrorMessage::ErrorMessage, 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::Cloud::Namespace::V1::CapacitySpec::OnDemand + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::Namespace::V1::CapacitySpec::OnDemand) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::OnDemand).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::OnDemand) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::OnDemand, 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::Cloud::Namespace::V1::CapacitySpec::Provisioned + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + value: T.nilable(Float) + ).void + end + def initialize( + value: 0.0 + ) + end + + # The units of provisioned capacity in TRU (Temporal Resource Units). +# Each TRU unit assigned to the namespace will entitle it with additional APS limits as specified in the documentation. + sig { returns(Float) } + def value + end + + # The units of provisioned capacity in TRU (Temporal Resource Units). +# Each TRU unit assigned to the namespace will entitle it with additional APS limits as specified in the documentation. + sig { params(value: Float).void } + def value=(value) + end + + # The units of provisioned capacity in TRU (Temporal Resource Units). +# Each TRU unit assigned to the namespace will entitle it with additional APS limits as specified in the documentation. + sig { void } + def clear_value + 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::Cloud::Namespace::V1::CapacitySpec::Provisioned) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::Provisioned).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::Provisioned) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::CapacitySpec::Provisioned, 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::Cloud::Namespace::V1::Capacity::OnDemand + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Cloud::Namespace::V1::Capacity::OnDemand) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Capacity::OnDemand).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::Capacity::OnDemand) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Capacity::OnDemand, 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::Cloud::Namespace::V1::Capacity::Provisioned + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + current_value: T.nilable(Float) + ).void + end + def initialize( + current_value: 0.0 + ) + end + + # The current provisioned capacity for the namespace in Temporal Resource Units. +# Can be different from the requested capacity in latest_request if the request is still in progress. + sig { returns(Float) } + def current_value + end + + # The current provisioned capacity for the namespace in Temporal Resource Units. +# Can be different from the requested capacity in latest_request if the request is still in progress. + sig { params(value: Float).void } + def current_value=(value) + end + + # The current provisioned capacity for the namespace in Temporal Resource Units. +# Can be different from the requested capacity in latest_request if the request is still in progress. + sig { void } + def clear_current_value + 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::Cloud::Namespace::V1::Capacity::Provisioned) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Capacity::Provisioned).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::Capacity::Provisioned) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Capacity::Provisioned, 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::Cloud::Namespace::V1::Capacity::Request + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + state: T.nilable(T.any(Symbol, String, Integer)), + start_time: T.nilable(Google::Protobuf::Timestamp), + end_time: T.nilable(Google::Protobuf::Timestamp), + async_operation_id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec) + ).void + end + def initialize( + state: :STATE_CAPACITY_REQUEST_UNSPECIFIED, + start_time: nil, + end_time: nil, + async_operation_id: "", + spec: nil + ) + end + + # The current state of the capacity request (e.g. in-progress, completed, failed). + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the capacity request (e.g. in-progress, completed, failed). + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the capacity request (e.g. in-progress, completed, failed). + sig { void } + def clear_state + end + + # The date and time when the capacity request was created. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # The date and time when the capacity request was created. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # The date and time when the capacity request was created. + sig { void } + def clear_start_time + end + + # The date and time when the capacity request was completed or failed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def end_time + end + + # The date and time when the capacity request was completed or failed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def end_time=(value) + end + + # The date and time when the capacity request was completed or failed. + sig { void } + def clear_end_time + end + + # The id of the async operation that is creating/updating/deleting the capacity, if any. + sig { returns(String) } + def async_operation_id + end + + # The id of the async operation that is creating/updating/deleting the capacity, if any. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of the async operation that is creating/updating/deleting the capacity, if any. + sig { void } + def clear_async_operation_id + end + + # The requested capacity specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec)) } + def spec + end + + # The requested capacity specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::CapacitySpec)).void } + def spec=(value) + end + + # The requested capacity specification. + sig { void } + def clear_spec + 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::Cloud::Namespace::V1::Capacity::Request) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Capacity::Request).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::Capacity::Request) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::Capacity::Request, 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::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + provisioned: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::Provisioned), + on_demand: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::OnDemand) + ).void + end + def initialize( + provisioned: nil, + on_demand: nil + ) + end + + # Provisioned capacity options and entitlements. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::Provisioned)) } + def provisioned + end + + # Provisioned capacity options and entitlements. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::Provisioned)).void } + def provisioned=(value) + end + + # Provisioned capacity options and entitlements. + sig { void } + def clear_provisioned + end + + # On-Demand capacity information. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::OnDemand)) } + def on_demand + end + + # On-Demand capacity information. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::OnDemand)).void } + def on_demand=(value) + end + + # On-Demand capacity information. + sig { void } + def clear_on_demand + 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::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions, 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::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + aps: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats::Summary) + ).void + end + def initialize( + aps: nil + ) + end + + # Actions-per-second measurements summarized over the last 7 days. + sig { returns(T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats::Summary)) } + def aps + end + + # Actions-per-second measurements summarized over the last 7 days. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats::Summary)).void } + def aps=(value) + end + + # Actions-per-second measurements summarized over the last 7 days. + sig { void } + def clear_aps + 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::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats, 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::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::Provisioned + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + valid_tru_values: T.nilable(T::Array[Float]), + max_available_tru_value: T.nilable(Float) + ).void + end + def initialize( + valid_tru_values: [], + max_available_tru_value: 0.0 + ) + end + + # The valid TRU (Temporal Resource Unit) values that can be set. +# These are the discrete capacity tiers available for selection. + sig { returns(T::Array[Float]) } + def valid_tru_values + end + + # The valid TRU (Temporal Resource Unit) values that can be set. +# These are the discrete capacity tiers available for selection. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def valid_tru_values=(value) + end + + # The valid TRU (Temporal Resource Unit) values that can be set. +# These are the discrete capacity tiers available for selection. + sig { void } + def clear_valid_tru_values + end + + # The maximum TRU value that can currently be set for this namespace. +# This may be lower than the highest value in valid_tru_values due to +# inventory constraints. + sig { returns(Float) } + def max_available_tru_value + end + + # The maximum TRU value that can currently be set for this namespace. +# This may be lower than the highest value in valid_tru_values due to +# inventory constraints. + sig { params(value: Float).void } + def max_available_tru_value=(value) + end + + # The maximum TRU value that can currently be set for this namespace. +# This may be lower than the highest value in valid_tru_values due to +# inventory constraints. + sig { void } + def clear_max_available_tru_value + 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::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::Provisioned) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::Provisioned).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::Provisioned) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::Provisioned, 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::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::OnDemand + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + aps_limit: T.nilable(Float) + ).void + end + def initialize( + aps_limit: 0.0 + ) + end + + # The APS limit that would apply to this namespace in on-demand mode. +# See: https://docs.temporal.io/cloud/limits#actions-per-second + sig { returns(Float) } + def aps_limit + end + + # The APS limit that would apply to this namespace in on-demand mode. +# See: https://docs.temporal.io/cloud/limits#actions-per-second + sig { params(value: Float).void } + def aps_limit=(value) + end + + # The APS limit that would apply to this namespace in on-demand mode. +# See: https://docs.temporal.io/cloud/limits#actions-per-second + sig { void } + def clear_aps_limit + 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::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::OnDemand) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::OnDemand).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::OnDemand) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::CapacityModeOptions::OnDemand, 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::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats::Summary + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + mean: T.nilable(Float), + p90: T.nilable(Float), + p99: T.nilable(Float) + ).void + end + def initialize( + mean: 0.0, + p90: 0.0, + p99: 0.0 + ) + end + + sig { returns(Float) } + def mean + end + + sig { params(value: Float).void } + def mean=(value) + end + + sig { void } + def clear_mean + end + + sig { returns(Float) } + def p90 + end + + sig { params(value: Float).void } + def p90=(value) + end + + sig { void } + def clear_p90 + end + + sig { returns(Float) } + def p99 + end + + sig { params(value: Float).void } + def p99=(value) + end + + sig { void } + def clear_p99 + 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::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats::Summary) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats::Summary).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats::Summary) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Namespace::V1::NamespaceCapacityInfo::Stats::Summary, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Namespace::V1::Capacity::Request::State + self::STATE_CAPACITY_REQUEST_UNSPECIFIED = T.let(0, Integer) + self::STATE_CAPACITY_REQUEST_COMPLETED = T.let(1, Integer) + self::STATE_CAPACITY_REQUEST_IN_PROGRESS = T.let(2, Integer) + self::STATE_CAPACITY_REQUEST_FAILED = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Namespace::V1::NamespaceSpec::SearchAttributeType + self::SEARCH_ATTRIBUTE_TYPE_UNSPECIFIED = T.let(0, Integer) + self::SEARCH_ATTRIBUTE_TYPE_TEXT = T.let(1, Integer) + self::SEARCH_ATTRIBUTE_TYPE_KEYWORD = T.let(2, Integer) + self::SEARCH_ATTRIBUTE_TYPE_INT = T.let(3, Integer) + self::SEARCH_ATTRIBUTE_TYPE_DOUBLE = T.let(4, Integer) + self::SEARCH_ATTRIBUTE_TYPE_BOOL = T.let(5, Integer) + self::SEARCH_ATTRIBUTE_TYPE_DATETIME = T.let(6, Integer) + self::SEARCH_ATTRIBUTE_TYPE_KEYWORD_LIST = T.let(7, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Namespace::V1::NamespaceRegionStatus::State + self::STATE_UNSPECIFIED = T.let(0, Integer) + self::STATE_ADDING = T.let(1, Integer) + self::STATE_ACTIVE = T.let(2, Integer) + self::STATE_PASSIVE = T.let(3, Integer) + self::STATE_REMOVING = T.let(4, Integer) + self::STATE_FAILED = T.let(5, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Namespace::V1::ExportSink::Health + self::HEALTH_UNSPECIFIED = T.let(0, Integer) + self::HEALTH_OK = T.let(1, Integer) + self::HEALTH_ERROR_INTERNAL = T.let(2, Integer) + self::HEALTH_ERROR_USER_CONFIGURATION = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/nexus/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/nexus/v1/message.rbi new file mode 100644 index 00000000..8f1e6863 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/nexus/v1/message.rbi @@ -0,0 +1,595 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/nexus/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Nexus::V1::EndpointSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + target_spec: T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointTargetSpec), + policy_specs: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointPolicySpec)]), + description_deprecated: T.nilable(String), + description: T.nilable(Temporalio::Api::Common::V1::Payload) + ).void + end + def initialize( + name: "", + target_spec: nil, + policy_specs: [], + description_deprecated: "", + description: nil + ) + end + + # The name of the endpoint. Must be unique within an account. +# The name must match `^[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9]$`. +# This field is mutable. + sig { returns(String) } + def name + end + + # The name of the endpoint. Must be unique within an account. +# The name must match `^[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9]$`. +# This field is mutable. + sig { params(value: String).void } + def name=(value) + end + + # The name of the endpoint. Must be unique within an account. +# The name must match `^[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9]$`. +# This field is mutable. + sig { void } + def clear_name + end + + # Indicates where the endpoint should forward received nexus requests to. + sig { returns(T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointTargetSpec)) } + def target_spec + end + + # Indicates where the endpoint should forward received nexus requests to. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointTargetSpec)).void } + def target_spec=(value) + end + + # Indicates where the endpoint should forward received nexus requests to. + sig { void } + def clear_target_spec + end + + # The set of policies (e.g. authorization) for the endpoint. Each request's caller +# must match with at least one of the specs to be accepted by the endpoint. +# This field is mutable. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointPolicySpec)]) } + def policy_specs + end + + # The set of policies (e.g. authorization) for the endpoint. Each request's caller +# must match with at least one of the specs to be accepted by the endpoint. +# This field is mutable. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def policy_specs=(value) + end + + # The set of policies (e.g. authorization) for the endpoint. Each request's caller +# must match with at least one of the specs to be accepted by the endpoint. +# This field is mutable. + sig { void } + def clear_policy_specs + end + + # Deprecated: Not supported after v0.4.0 api version. Use description instead. +# temporal:versioning:max_version=v0.4.0 + sig { returns(String) } + def description_deprecated + end + + # Deprecated: Not supported after v0.4.0 api version. Use description instead. +# temporal:versioning:max_version=v0.4.0 + sig { params(value: String).void } + def description_deprecated=(value) + end + + # Deprecated: Not supported after v0.4.0 api version. Use description instead. +# temporal:versioning:max_version=v0.4.0 + sig { void } + def clear_description_deprecated + end + + # The markdown description of the endpoint - optional. +# temporal:versioning:min_version=v0.4.0 + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def description + end + + # The markdown description of the endpoint - optional. +# temporal:versioning:min_version=v0.4.0 + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def description=(value) + end + + # The markdown description of the endpoint - optional. +# temporal:versioning:min_version=v0.4.0 + sig { void } + def clear_description + 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::Cloud::Nexus::V1::EndpointSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::EndpointSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::EndpointSpec, 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::Cloud::Nexus::V1::EndpointTargetSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_target_spec: T.nilable(Temporalio::Api::Cloud::Nexus::V1::WorkerTargetSpec) + ).void + end + def initialize( + worker_target_spec: nil + ) + end + + # A target spec for routing nexus requests to a specific cloud namespace worker. + sig { returns(T.nilable(Temporalio::Api::Cloud::Nexus::V1::WorkerTargetSpec)) } + def worker_target_spec + end + + # A target spec for routing nexus requests to a specific cloud namespace worker. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Nexus::V1::WorkerTargetSpec)).void } + def worker_target_spec=(value) + end + + # A target spec for routing nexus requests to a specific cloud namespace worker. + sig { void } + def clear_worker_target_spec + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Cloud::Nexus::V1::EndpointTargetSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::EndpointTargetSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Nexus::V1::EndpointTargetSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::EndpointTargetSpec, 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::Cloud::Nexus::V1::WorkerTargetSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace_id: T.nilable(String), + task_queue: T.nilable(String) + ).void + end + def initialize( + namespace_id: "", + task_queue: "" + ) + end + + # The target cloud namespace to route requests to. Namespace must be in same account as the endpoint. This field is mutable. + sig { returns(String) } + def namespace_id + end + + # The target cloud namespace to route requests to. Namespace must be in same account as the endpoint. This field is mutable. + sig { params(value: String).void } + def namespace_id=(value) + end + + # The target cloud namespace to route requests to. Namespace must be in same account as the endpoint. This field is mutable. + sig { void } + def clear_namespace_id + end + + # The task queue on the cloud namespace to route requests to. This field is mutable. + sig { returns(String) } + def task_queue + end + + # The task queue on the cloud namespace to route requests to. This field is mutable. + sig { params(value: String).void } + def task_queue=(value) + end + + # The task queue on the cloud namespace to route requests to. This field is mutable. + sig { void } + def clear_task_queue + 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::Cloud::Nexus::V1::WorkerTargetSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::WorkerTargetSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Nexus::V1::WorkerTargetSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::WorkerTargetSpec, 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::Cloud::Nexus::V1::EndpointPolicySpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + allowed_cloud_namespace_policy_spec: T.nilable(Temporalio::Api::Cloud::Nexus::V1::AllowedCloudNamespacePolicySpec) + ).void + end + def initialize( + allowed_cloud_namespace_policy_spec: nil + ) + end + + # A policy spec that allows one caller namespace to access the endpoint. + sig { returns(T.nilable(Temporalio::Api::Cloud::Nexus::V1::AllowedCloudNamespacePolicySpec)) } + def allowed_cloud_namespace_policy_spec + end + + # A policy spec that allows one caller namespace to access the endpoint. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Nexus::V1::AllowedCloudNamespacePolicySpec)).void } + def allowed_cloud_namespace_policy_spec=(value) + end + + # A policy spec that allows one caller namespace to access the endpoint. + sig { void } + def clear_allowed_cloud_namespace_policy_spec + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Cloud::Nexus::V1::EndpointPolicySpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::EndpointPolicySpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Nexus::V1::EndpointPolicySpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::EndpointPolicySpec, 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::Cloud::Nexus::V1::AllowedCloudNamespacePolicySpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace_id: T.nilable(String) + ).void + end + def initialize( + namespace_id: "" + ) + end + + # The namespace that is allowed to call into this endpoint. Calling namespace must be in same account as the endpoint. + sig { returns(String) } + def namespace_id + end + + # The namespace that is allowed to call into this endpoint. Calling namespace must be in same account as the endpoint. + sig { params(value: String).void } + def namespace_id=(value) + end + + # The namespace that is allowed to call into this endpoint. Calling namespace must be in same account as the endpoint. + sig { void } + def clear_namespace_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::Cloud::Nexus::V1::AllowedCloudNamespacePolicySpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::AllowedCloudNamespacePolicySpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Nexus::V1::AllowedCloudNamespacePolicySpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::AllowedCloudNamespacePolicySpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# An endpoint that receives and then routes Nexus requests +class Temporalio::Api::Cloud::Nexus::V1::Endpoint + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + resource_version: T.nilable(String), + spec: T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec), + state: T.nilable(T.any(Symbol, String, Integer)), + async_operation_id: T.nilable(String), + created_time: T.nilable(Google::Protobuf::Timestamp), + last_modified_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + id: "", + resource_version: "", + spec: nil, + state: :RESOURCE_STATE_UNSPECIFIED, + async_operation_id: "", + created_time: nil, + last_modified_time: nil + ) + end + + # The id of the endpoint. This is generated by the server and is immutable. + sig { returns(String) } + def id + end + + # The id of the endpoint. This is generated by the server and is immutable. + sig { params(value: String).void } + def id=(value) + end + + # The id of the endpoint. This is generated by the server and is immutable. + sig { void } + def clear_id + end + + # The current version of the endpoint specification. +# The next update operation must include this version. + sig { returns(String) } + def resource_version + end + + # The current version of the endpoint specification. +# The next update operation must include this version. + sig { params(value: String).void } + def resource_version=(value) + end + + # The current version of the endpoint specification. +# The next update operation must include this version. + sig { void } + def clear_resource_version + end + + # The endpoint specification. + sig { returns(T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec)) } + def spec + end + + # The endpoint specification. + sig { params(value: T.nilable(Temporalio::Api::Cloud::Nexus::V1::EndpointSpec)).void } + def spec=(value) + end + + # The endpoint specification. + sig { void } + def clear_spec + end + + # The current state of the endpoint. +# For any failed state, reach out to Temporal Cloud support for remediation. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of the endpoint. +# For any failed state, reach out to Temporal Cloud support for remediation. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of the endpoint. +# For any failed state, reach out to Temporal Cloud support for remediation. + sig { void } + def clear_state + end + + # The id of any ongoing async operation that is creating, updating, or deleting the endpoint, if any. + sig { returns(String) } + def async_operation_id + end + + # The id of any ongoing async operation that is creating, updating, or deleting the endpoint, if any. + sig { params(value: String).void } + def async_operation_id=(value) + end + + # The id of any ongoing async operation that is creating, updating, or deleting the endpoint, if any. + sig { void } + def clear_async_operation_id + end + + # The date and time when the endpoint was created. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the endpoint was created. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the endpoint was created. + sig { void } + def clear_created_time + end + + # The date and time when the endpoint was last modified. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_modified_time + end + + # The date and time when the endpoint was last modified. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_modified_time=(value) + end + + # The date and time when the endpoint was last modified. + sig { void } + def clear_last_modified_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::Cloud::Nexus::V1::Endpoint) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::Endpoint).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Nexus::V1::Endpoint) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Nexus::V1::Endpoint, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/operation/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/operation/v1/message.rbi new file mode 100644 index 00000000..684c4130 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/operation/v1/message.rbi @@ -0,0 +1,244 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/operation/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Operation::V1::AsyncOperation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + state_deprecated: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + check_duration: T.nilable(Google::Protobuf::Duration), + operation_type: T.nilable(String), + operation_input: T.nilable(Google::Protobuf::Any), + failure_reason: T.nilable(String), + started_time: T.nilable(Google::Protobuf::Timestamp), + finished_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + id: "", + state_deprecated: "", + state: :STATE_UNSPECIFIED, + check_duration: nil, + operation_type: "", + operation_input: nil, + failure_reason: "", + started_time: nil, + finished_time: nil + ) + end + + # The operation id. + sig { returns(String) } + def id + end + + # The operation id. + sig { params(value: String).void } + def id=(value) + end + + # The operation id. + sig { void } + def clear_id + end + + # The current state of this operation. +# Possible values are: pending, in_progress, failed, cancelled, fulfilled. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def state_deprecated + end + + # The current state of this operation. +# Possible values are: pending, in_progress, failed, cancelled, fulfilled. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def state_deprecated=(value) + end + + # The current state of this operation. +# Possible values are: pending, in_progress, failed, cancelled, fulfilled. +# Deprecated: Not supported after v0.3.0 api version. Use state instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_state_deprecated + end + + # The current state of this operation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # The current state of this operation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # The current state of this operation. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=state_deprecated + sig { void } + def clear_state + end + + # The recommended duration to check back for an update in the operation's state. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def check_duration + end + + # The recommended duration to check back for an update in the operation's state. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def check_duration=(value) + end + + # The recommended duration to check back for an update in the operation's state. + sig { void } + def clear_check_duration + end + + # The type of operation being performed. + sig { returns(String) } + def operation_type + end + + # The type of operation being performed. + sig { params(value: String).void } + def operation_type=(value) + end + + # The type of operation being performed. + sig { void } + def clear_operation_type + end + + # The input to the operation being performed. +# +# (-- api-linter: core::0146::any=disabled --) + sig { returns(T.nilable(Google::Protobuf::Any)) } + def operation_input + end + + # The input to the operation being performed. +# +# (-- api-linter: core::0146::any=disabled --) + sig { params(value: T.nilable(Google::Protobuf::Any)).void } + def operation_input=(value) + end + + # The input to the operation being performed. +# +# (-- api-linter: core::0146::any=disabled --) + sig { void } + def clear_operation_input + end + + # If the operation failed, the reason for the failure. + sig { returns(String) } + def failure_reason + end + + # If the operation failed, the reason for the failure. + sig { params(value: String).void } + def failure_reason=(value) + end + + # If the operation failed, the reason for the failure. + sig { void } + def clear_failure_reason + end + + # The date and time when the operation initiated. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def started_time + end + + # The date and time when the operation initiated. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def started_time=(value) + end + + # The date and time when the operation initiated. + sig { void } + def clear_started_time + end + + # The date and time when the operation completed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def finished_time + end + + # The date and time when the operation completed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def finished_time=(value) + end + + # The date and time when the operation completed. + sig { void } + def clear_finished_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::Cloud::Operation::V1::AsyncOperation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Operation::V1::AsyncOperation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Operation::V1::AsyncOperation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Operation::V1::AsyncOperation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Operation::V1::AsyncOperation::State + self::STATE_UNSPECIFIED = T.let(0, Integer) + self::STATE_PENDING = T.let(1, Integer) + self::STATE_IN_PROGRESS = T.let(2, Integer) + self::STATE_FAILED = T.let(3, Integer) + self::STATE_CANCELLED = T.let(4, Integer) + self::STATE_FULFILLED = T.let(5, Integer) + self::STATE_REJECTED = T.let(6, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/region/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/region/v1/message.rbi new file mode 100644 index 00000000..7a87ad93 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/region/v1/message.rbi @@ -0,0 +1,166 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/region/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Region::V1::Region + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + cloud_provider_deprecated: T.nilable(String), + cloud_provider: T.nilable(T.any(Symbol, String, Integer)), + cloud_provider_region: T.nilable(String), + location: T.nilable(String) + ).void + end + def initialize( + id: "", + cloud_provider_deprecated: "", + cloud_provider: :CLOUD_PROVIDER_UNSPECIFIED, + cloud_provider_region: "", + location: "" + ) + end + + # The id of the temporal cloud region. + sig { returns(String) } + def id + end + + # The id of the temporal cloud region. + sig { params(value: String).void } + def id=(value) + end + + # The id of the temporal cloud region. + sig { void } + def clear_id + end + + # The name of the cloud provider that's hosting the region. +# Currently only "aws" is supported. +# Deprecated: Not supported after v0.3.0 api version. Use cloud_provider instead. +# temporal:versioning:max_version=v0.3.0 + sig { returns(String) } + def cloud_provider_deprecated + end + + # The name of the cloud provider that's hosting the region. +# Currently only "aws" is supported. +# Deprecated: Not supported after v0.3.0 api version. Use cloud_provider instead. +# temporal:versioning:max_version=v0.3.0 + sig { params(value: String).void } + def cloud_provider_deprecated=(value) + end + + # The name of the cloud provider that's hosting the region. +# Currently only "aws" is supported. +# Deprecated: Not supported after v0.3.0 api version. Use cloud_provider instead. +# temporal:versioning:max_version=v0.3.0 + sig { void } + def clear_cloud_provider_deprecated + end + + # The cloud provider that's hosting the region. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=cloud_provider_deprecated + sig { returns(T.any(Symbol, Integer)) } + def cloud_provider + end + + # The cloud provider that's hosting the region. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=cloud_provider_deprecated + sig { params(value: T.any(Symbol, String, Integer)).void } + def cloud_provider=(value) + end + + # The cloud provider that's hosting the region. +# temporal:versioning:min_version=v0.3.0 +# temporal:enums:replaces=cloud_provider_deprecated + sig { void } + def clear_cloud_provider + end + + # The region identifier as defined by the cloud provider. + sig { returns(String) } + def cloud_provider_region + end + + # The region identifier as defined by the cloud provider. + sig { params(value: String).void } + def cloud_provider_region=(value) + end + + # The region identifier as defined by the cloud provider. + sig { void } + def clear_cloud_provider_region + end + + # The human readable location of the region. + sig { returns(String) } + def location + end + + # The human readable location of the region. + sig { params(value: String).void } + def location=(value) + end + + # The human readable location of the region. + sig { void } + def clear_location + 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::Cloud::Region::V1::Region) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Region::V1::Region).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Region::V1::Region) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Region::V1::Region, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Region::V1::Region::CloudProvider + self::CLOUD_PROVIDER_UNSPECIFIED = T.let(0, Integer) + self::CLOUD_PROVIDER_AWS = T.let(1, Integer) + self::CLOUD_PROVIDER_GCP = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/resource/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/resource/v1/message.rbi new file mode 100644 index 00000000..e1a61b10 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/resource/v1/message.rbi @@ -0,0 +1,29 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/resource/v1/message.proto +# typed: strict + +module Temporalio::Api::Cloud::Resource::V1::ResourceState + self::RESOURCE_STATE_UNSPECIFIED = T.let(0, Integer) + self::RESOURCE_STATE_ACTIVATING = T.let(1, Integer) + self::RESOURCE_STATE_ACTIVATION_FAILED = T.let(2, Integer) + self::RESOURCE_STATE_ACTIVE = T.let(3, Integer) + self::RESOURCE_STATE_UPDATING = T.let(4, Integer) + self::RESOURCE_STATE_UPDATE_FAILED = T.let(5, Integer) + self::RESOURCE_STATE_DELETING = T.let(6, Integer) + self::RESOURCE_STATE_DELETE_FAILED = T.let(7, Integer) + self::RESOURCE_STATE_DELETED = T.let(8, Integer) + self::RESOURCE_STATE_SUSPENDED = T.let(9, Integer) + self::RESOURCE_STATE_EXPIRED = T.let(10, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/sink/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/sink/v1/message.rbi new file mode 100644 index 00000000..a4b0c9c4 --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/sink/v1/message.rbi @@ -0,0 +1,438 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/sink/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Sink::V1::S3Spec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + role_name: T.nilable(String), + bucket_name: T.nilable(String), + region: T.nilable(String), + kms_arn: T.nilable(String), + aws_account_id: T.nilable(String) + ).void + end + def initialize( + role_name: "", + bucket_name: "", + region: "", + kms_arn: "", + aws_account_id: "" + ) + end + + # The IAM role that Temporal Cloud assumes for writing records to the customer's S3 bucket. + sig { returns(String) } + def role_name + end + + # The IAM role that Temporal Cloud assumes for writing records to the customer's S3 bucket. + sig { params(value: String).void } + def role_name=(value) + end + + # The IAM role that Temporal Cloud assumes for writing records to the customer's S3 bucket. + sig { void } + def clear_role_name + end + + # The name of the destination S3 bucket where Temporal will send data. + sig { returns(String) } + def bucket_name + end + + # The name of the destination S3 bucket where Temporal will send data. + sig { params(value: String).void } + def bucket_name=(value) + end + + # The name of the destination S3 bucket where Temporal will send data. + sig { void } + def clear_bucket_name + end + + # The region where the S3 bucket is located. + sig { returns(String) } + def region + end + + # The region where the S3 bucket is located. + sig { params(value: String).void } + def region=(value) + end + + # The region where the S3 bucket is located. + sig { void } + def clear_region + end + + # The AWS Key Management Service (KMS) ARN used for encryption. + sig { returns(String) } + def kms_arn + end + + # The AWS Key Management Service (KMS) ARN used for encryption. + sig { params(value: String).void } + def kms_arn=(value) + end + + # The AWS Key Management Service (KMS) ARN used for encryption. + sig { void } + def clear_kms_arn + end + + # The AWS account ID associated with the S3 bucket and the assumed role. + sig { returns(String) } + def aws_account_id + end + + # The AWS account ID associated with the S3 bucket and the assumed role. + sig { params(value: String).void } + def aws_account_id=(value) + end + + # The AWS account ID associated with the S3 bucket and the assumed role. + sig { void } + def clear_aws_account_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::Cloud::Sink::V1::S3Spec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Sink::V1::S3Spec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Sink::V1::S3Spec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Sink::V1::S3Spec, 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::Cloud::Sink::V1::GCSSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + sa_id: T.nilable(String), + bucket_name: T.nilable(String), + gcp_project_id: T.nilable(String), + region: T.nilable(String) + ).void + end + def initialize( + sa_id: "", + bucket_name: "", + gcp_project_id: "", + region: "" + ) + end + + # The customer service account ID that Temporal Cloud impersonates for writing records to the customer's GCS bucket. + sig { returns(String) } + def sa_id + end + + # The customer service account ID that Temporal Cloud impersonates for writing records to the customer's GCS bucket. + sig { params(value: String).void } + def sa_id=(value) + end + + # The customer service account ID that Temporal Cloud impersonates for writing records to the customer's GCS bucket. + sig { void } + def clear_sa_id + end + + # The name of the destination GCS bucket where Temporal will send data. + sig { returns(String) } + def bucket_name + end + + # The name of the destination GCS bucket where Temporal will send data. + sig { params(value: String).void } + def bucket_name=(value) + end + + # The name of the destination GCS bucket where Temporal will send data. + sig { void } + def clear_bucket_name + end + + # The GCP project ID associated with the GCS bucket and service account. + sig { returns(String) } + def gcp_project_id + end + + # The GCP project ID associated with the GCS bucket and service account. + sig { params(value: String).void } + def gcp_project_id=(value) + end + + # The GCP project ID associated with the GCS bucket and service account. + sig { void } + def clear_gcp_project_id + end + + # The region of the gcs bucket + sig { returns(String) } + def region + end + + # The region of the gcs bucket + sig { params(value: String).void } + def region=(value) + end + + # The region of the gcs bucket + sig { void } + def clear_region + 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::Cloud::Sink::V1::GCSSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Sink::V1::GCSSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Sink::V1::GCSSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Sink::V1::GCSSpec, 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::Cloud::Sink::V1::KinesisSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + role_name: T.nilable(String), + destination_uri: T.nilable(String), + region: T.nilable(String) + ).void + end + def initialize( + role_name: "", + destination_uri: "", + region: "" + ) + end + + # The role Temporal Cloud assumes when writing records to Kinesis + sig { returns(String) } + def role_name + end + + # The role Temporal Cloud assumes when writing records to Kinesis + sig { params(value: String).void } + def role_name=(value) + end + + # The role Temporal Cloud assumes when writing records to Kinesis + sig { void } + def clear_role_name + end + + # Destination Kinesis endpoint arn for temporal to send data to. + sig { returns(String) } + def destination_uri + end + + # Destination Kinesis endpoint arn for temporal to send data to. + sig { params(value: String).void } + def destination_uri=(value) + end + + # Destination Kinesis endpoint arn for temporal to send data to. + sig { void } + def clear_destination_uri + end + + # The sink's region. + sig { returns(String) } + def region + end + + # The sink's region. + sig { params(value: String).void } + def region=(value) + end + + # The sink's region. + sig { void } + def clear_region + 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::Cloud::Sink::V1::KinesisSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Sink::V1::KinesisSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Sink::V1::KinesisSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Sink::V1::KinesisSpec, 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::Cloud::Sink::V1::PubSubSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service_account_id: T.nilable(String), + topic_name: T.nilable(String), + gcp_project_id: T.nilable(String) + ).void + end + def initialize( + service_account_id: "", + topic_name: "", + gcp_project_id: "" + ) + end + + # The customer service account id that Temporal Cloud impersonates for writing records to customer's pubsub topic + sig { returns(String) } + def service_account_id + end + + # The customer service account id that Temporal Cloud impersonates for writing records to customer's pubsub topic + sig { params(value: String).void } + def service_account_id=(value) + end + + # The customer service account id that Temporal Cloud impersonates for writing records to customer's pubsub topic + sig { void } + def clear_service_account_id + end + + # Destination pubsub topic name for us + sig { returns(String) } + def topic_name + end + + # Destination pubsub topic name for us + sig { params(value: String).void } + def topic_name=(value) + end + + # Destination pubsub topic name for us + sig { void } + def clear_topic_name + end + + # The gcp project id of pubsub topic and service account + sig { returns(String) } + def gcp_project_id + end + + # The gcp project id of pubsub topic and service account + sig { params(value: String).void } + def gcp_project_id=(value) + end + + # The gcp project id of pubsub topic and service account + sig { void } + def clear_gcp_project_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::Cloud::Sink::V1::PubSubSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Sink::V1::PubSubSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Sink::V1::PubSubSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Sink::V1::PubSubSpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/cloud/usage/v1/message.rbi b/temporalio/rbi/temporalio/api/cloud/usage/v1/message.rbi new file mode 100644 index 00000000..5f88934d --- /dev/null +++ b/temporalio/rbi/temporalio/api/cloud/usage/v1/message.rbi @@ -0,0 +1,409 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/cloud/usage/v1/message.proto +# typed: strict + +class Temporalio::Api::Cloud::Usage::V1::Summary + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_time: T.nilable(Google::Protobuf::Timestamp), + end_time: T.nilable(Google::Protobuf::Timestamp), + record_groups: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Usage::V1::RecordGroup)]), + incomplete: T.nilable(T::Boolean) + ).void + end + def initialize( + start_time: nil, + end_time: nil, + record_groups: [], + incomplete: false + ) + end + + # Start of UTC day for now (inclusive) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # Start of UTC day for now (inclusive) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # Start of UTC day for now (inclusive) + sig { void } + def clear_start_time + end + + # End of UTC day for now (exclusive) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def end_time + end + + # End of UTC day for now (exclusive) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def end_time=(value) + end + + # End of UTC day for now (exclusive) + sig { void } + def clear_end_time + end + + # Records grouped by namespace + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Usage::V1::RecordGroup)]) } + def record_groups + end + + # Records grouped by namespace + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def record_groups=(value) + end + + # Records grouped by namespace + sig { void } + def clear_record_groups + end + + # True if data for given time window is not fully available yet (e.g. delays) +# When true, records for the given time range could still be added/updated in the future (until false) + sig { returns(T::Boolean) } + def incomplete + end + + # True if data for given time window is not fully available yet (e.g. delays) +# When true, records for the given time range could still be added/updated in the future (until false) + sig { params(value: T::Boolean).void } + def incomplete=(value) + end + + # True if data for given time window is not fully available yet (e.g. delays) +# When true, records for the given time range could still be added/updated in the future (until false) + sig { void } + def clear_incomplete + 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::Cloud::Usage::V1::Summary) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Usage::V1::Summary).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Usage::V1::Summary) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Usage::V1::Summary, 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::Cloud::Usage::V1::RecordGroup + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_bys: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Usage::V1::GroupBy)]), + records: T.nilable(T::Array[T.nilable(Temporalio::Api::Cloud::Usage::V1::Record)]) + ).void + end + def initialize( + group_bys: [], + records: [] + ) + end + + # GroupBy keys and their values for this record group. Multiple fields are combined with logical AND. + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Usage::V1::GroupBy)]) } + def group_bys + end + + # GroupBy keys and their values for this record group. Multiple fields are combined with logical AND. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def group_bys=(value) + end + + # GroupBy keys and their values for this record group. Multiple fields are combined with logical AND. + sig { void } + def clear_group_bys + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Cloud::Usage::V1::Record)]) } + def records + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def records=(value) + end + + sig { void } + def clear_records + 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::Cloud::Usage::V1::RecordGroup) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Usage::V1::RecordGroup).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Usage::V1::RecordGroup) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Usage::V1::RecordGroup, 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::Cloud::Usage::V1::GroupBy + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + key: T.nilable(T.any(Symbol, String, Integer)), + value: T.nilable(String) + ).void + end + def initialize( + key: :GROUP_BY_KEY_UNSPECIFIED, + value: "" + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def key + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def key=(value) + end + + sig { void } + def clear_key + end + + sig { returns(String) } + def value + end + + sig { params(value: String).void } + def value=(value) + end + + sig { void } + def clear_value + 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::Cloud::Usage::V1::GroupBy) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Usage::V1::GroupBy).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Usage::V1::GroupBy) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Usage::V1::GroupBy, 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::Cloud::Usage::V1::Record + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(T.any(Symbol, String, Integer)), + unit: T.nilable(T.any(Symbol, String, Integer)), + value: T.nilable(Float) + ).void + end + def initialize( + type: :RECORD_TYPE_UNSPECIFIED, + unit: :RECORD_UNIT_UNSPECIFIED, + value: 0.0 + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def type=(value) + end + + sig { void } + def clear_type + end + + sig { returns(T.any(Symbol, Integer)) } + def unit + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def unit=(value) + end + + sig { void } + def clear_unit + end + + sig { returns(Float) } + def value + end + + sig { params(value: Float).void } + def value=(value) + end + + sig { void } + def clear_value + 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::Cloud::Usage::V1::Record) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Cloud::Usage::V1::Record).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Cloud::Usage::V1::Record) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Cloud::Usage::V1::Record, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Usage::V1::RecordType + self::RECORD_TYPE_UNSPECIFIED = T.let(0, Integer) + self::RECORD_TYPE_ACTIONS = T.let(1, Integer) + self::RECORD_TYPE_ACTIVE_STORAGE = T.let(2, Integer) + self::RECORD_TYPE_RETAINED_STORAGE = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Usage::V1::RecordUnit + self::RECORD_UNIT_UNSPECIFIED = T.let(0, Integer) + self::RECORD_UNIT_NUMBER = T.let(1, Integer) + self::RECORD_UNIT_BYTE_SECONDS = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Cloud::Usage::V1::GroupByKey + self::GROUP_BY_KEY_UNSPECIFIED = T.let(0, Integer) + self::GROUP_BY_KEY_NAMESPACE = T.let(1, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/command/v1/message.rbi b/temporalio/rbi/temporalio/api/command/v1/message.rbi new file mode 100644 index 00000000..af8017dd --- /dev/null +++ b/temporalio/rbi/temporalio/api/command/v1/message.rbi @@ -0,0 +1,2638 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/command/v1/message.proto +# typed: strict + +class Temporalio::Api::Command::V1::ScheduleActivityTaskCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_id: T.nilable(String), + activity_type: T.nilable(Temporalio::Api::Common::V1::ActivityType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + header: T.nilable(Temporalio::Api::Common::V1::Header), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + heartbeat_timeout: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + request_eager_execution: T.nilable(T::Boolean), + use_workflow_build_id: T.nilable(T::Boolean), + priority: T.nilable(Temporalio::Api::Common::V1::Priority) + ).void + end + def initialize( + activity_id: "", + activity_type: nil, + task_queue: nil, + header: nil, + input: nil, + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + heartbeat_timeout: nil, + retry_policy: nil, + request_eager_execution: false, + use_workflow_build_id: false, + priority: nil + ) + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::ActivityType)) } + def activity_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ActivityType)).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + sig { void } + def clear_input + end + + # Indicates how long the caller is willing to wait for activity completion. The "schedule" time +# is when the activity is initially scheduled, not when the most recent retry is scheduled. +# Limits how long retries will be attempted. Either this or `start_to_close_timeout` must be +# specified. When not specified, defaults to the workflow execution timeout. +# +# (-- 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_close_timeout + end + + # Indicates how long the caller is willing to wait for activity completion. The "schedule" time +# is when the activity is initially scheduled, not when the most recent retry is scheduled. +# Limits how long retries will be attempted. Either this or `start_to_close_timeout` must be +# specified. When not specified, defaults to the workflow execution timeout. +# +# (-- 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_close_timeout=(value) + end + + # Indicates how long the caller is willing to wait for activity completion. The "schedule" time +# is when the activity is initially scheduled, not when the most recent retry is scheduled. +# Limits how long retries will be attempted. Either this or `start_to_close_timeout` must be +# specified. When not specified, defaults to the workflow execution timeout. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Limits the time an activity task can stay in a task queue before a worker picks it up. The +# "schedule" time is when the most recent retry is scheduled. This timeout should usually not +# be set: it's useful in specific scenarios like worker-specific task queues. This timeout is +# always non retryable, as all a retry would achieve is to put it back into the same queue. +# Defaults to `schedule_to_close_timeout` or workflow execution timeout if that is not +# specified. More info: +# https://docs.temporal.io/docs/content/what-is-a-schedule-to-start-timeout/ +# +# (-- 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 + + # Limits the time an activity task can stay in a task queue before a worker picks it up. The +# "schedule" time is when the most recent retry is scheduled. This timeout should usually not +# be set: it's useful in specific scenarios like worker-specific task queues. This timeout is +# always non retryable, as all a retry would achieve is to put it back into the same queue. +# Defaults to `schedule_to_close_timeout` or workflow execution timeout if that is not +# specified. More info: +# https://docs.temporal.io/docs/content/what-is-a-schedule-to-start-timeout/ +# +# (-- 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 + + # Limits the time an activity task can stay in a task queue before a worker picks it up. The +# "schedule" time is when the most recent retry is scheduled. This timeout should usually not +# be set: it's useful in specific scenarios like worker-specific task queues. This timeout is +# always non retryable, as all a retry would achieve is to put it back into the same queue. +# Defaults to `schedule_to_close_timeout` or workflow execution timeout if that is not +# specified. More info: +# https://docs.temporal.io/docs/content/what-is-a-schedule-to-start-timeout/ +# +# (-- 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 + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be specified. +# +# (-- 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 start_to_close_timeout=(value) + end + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def heartbeat_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def heartbeat_timeout=(value) + end + + # Maximum permitted time between successful worker heartbeats. + sig { void } + def clear_heartbeat_timeout + end + + # Activities are provided by a default retry policy which is controlled through the service's +# dynamic configuration. Retries will be attempted until `schedule_to_close_timeout` has +# elapsed. To disable retries set retry_policy.maximum_attempts to 1. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # Activities are provided by a default retry policy which is controlled through the service's +# dynamic configuration. Retries will be attempted until `schedule_to_close_timeout` has +# elapsed. To disable retries set retry_policy.maximum_attempts to 1. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # Activities are provided by a default retry policy which is controlled through the service's +# dynamic configuration. Retries will be attempted until `schedule_to_close_timeout` has +# elapsed. To disable retries set retry_policy.maximum_attempts to 1. + sig { void } + def clear_retry_policy + end + + # Request to start the activity directly bypassing matching service and worker polling +# The slot for executing the activity should be reserved when setting this field to true. + sig { returns(T::Boolean) } + def request_eager_execution + end + + # Request to start the activity directly bypassing matching service and worker polling +# The slot for executing the activity should be reserved when setting this field to true. + sig { params(value: T::Boolean).void } + def request_eager_execution=(value) + end + + # Request to start the activity directly bypassing matching service and worker polling +# The slot for executing the activity should be reserved when setting this field to true. + sig { void } + def clear_request_eager_execution + end + + # If this is set, the activity would be assigned to the Build ID of the workflow. Otherwise, +# Assignment rules of the activity's Task Queue will be used to determine the Build ID. + sig { returns(T::Boolean) } + def use_workflow_build_id + end + + # If this is set, the activity would be assigned to the Build ID of the workflow. Otherwise, +# Assignment rules of the activity's Task Queue will be used to determine the Build ID. + sig { params(value: T::Boolean).void } + def use_workflow_build_id=(value) + end + + # If this is set, the activity would be assigned to the Build ID of the workflow. Otherwise, +# Assignment rules of the activity's Task Queue will be used to determine the Build ID. + sig { void } + def clear_use_workflow_build_id + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { void } + def clear_priority + 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::Command::V1::ScheduleActivityTaskCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::ScheduleActivityTaskCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::ScheduleActivityTaskCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::ScheduleActivityTaskCommandAttributes, 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::Command::V1::RequestCancelActivityTaskCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer) + ).void + end + def initialize( + scheduled_event_id: 0 + ) + end + + # The `ACTIVITY_TASK_SCHEDULED` event id for the activity being cancelled. + sig { returns(Integer) } + def scheduled_event_id + end + + # The `ACTIVITY_TASK_SCHEDULED` event id for the activity being cancelled. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The `ACTIVITY_TASK_SCHEDULED` event id for the activity being cancelled. + sig { void } + def clear_scheduled_event_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::Command::V1::RequestCancelActivityTaskCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::RequestCancelActivityTaskCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::RequestCancelActivityTaskCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::RequestCancelActivityTaskCommandAttributes, 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::Command::V1::StartTimerCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + timer_id: T.nilable(String), + start_to_fire_timeout: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + timer_id: "", + start_to_fire_timeout: nil + ) + end + + # An id for the timer, currently live timers must have different ids. Typically autogenerated +# by the SDK. + sig { returns(String) } + def timer_id + end + + # An id for the timer, currently live timers must have different ids. Typically autogenerated +# by the SDK. + sig { params(value: String).void } + def timer_id=(value) + end + + # An id for the timer, currently live timers must have different ids. Typically autogenerated +# by the SDK. + sig { void } + def clear_timer_id + end + + # How long until the timer fires, producing a `TIMER_FIRED` event. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_fire_timeout + end + + # How long until the timer fires, producing a `TIMER_FIRED` event. +# +# (-- 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 start_to_fire_timeout=(value) + end + + # How long until the timer fires, producing a `TIMER_FIRED` event. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_fire_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::Command::V1::StartTimerCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::StartTimerCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::StartTimerCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::StartTimerCommandAttributes, 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::Command::V1::CompleteWorkflowExecutionCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result: T.nilable(Temporalio::Api::Common::V1::Payloads) + ).void + end + def initialize( + result: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def result=(value) + end + + sig { void } + def clear_result + 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::Command::V1::CompleteWorkflowExecutionCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::CompleteWorkflowExecutionCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::CompleteWorkflowExecutionCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::CompleteWorkflowExecutionCommandAttributes, 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::Command::V1::FailWorkflowExecutionCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Command::V1::FailWorkflowExecutionCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::FailWorkflowExecutionCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::FailWorkflowExecutionCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::FailWorkflowExecutionCommandAttributes, 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::Command::V1::CancelTimerCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + timer_id: T.nilable(String) + ).void + end + def initialize( + timer_id: "" + ) + end + + # The same timer id from the start timer command + sig { returns(String) } + def timer_id + end + + # The same timer id from the start timer command + sig { params(value: String).void } + def timer_id=(value) + end + + # The same timer id from the start timer command + sig { void } + def clear_timer_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::Command::V1::CancelTimerCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::CancelTimerCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::CancelTimerCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::CancelTimerCommandAttributes, 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::Command::V1::CancelWorkflowExecutionCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + details: T.nilable(Temporalio::Api::Common::V1::Payloads) + ).void + end + def initialize( + details: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + sig { void } + def clear_details + 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::Command::V1::CancelWorkflowExecutionCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::CancelWorkflowExecutionCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::CancelWorkflowExecutionCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::CancelWorkflowExecutionCommandAttributes, 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::Command::V1::RequestCancelExternalWorkflowExecutionCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String), + control: T.nilable(String), + child_workflow_only: T.nilable(T::Boolean), + reason: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "", + control: "", + child_workflow_only: false, + reason: "" + ) + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { returns(String) } + def namespace + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { params(value: String).void } + def namespace=(value) + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + end + + # Set this to true if the workflow being cancelled is a child of the workflow originating this +# command. The request will be rejected if it is set to true and the target workflow is *not* +# a child of the requesting workflow. + sig { returns(T::Boolean) } + def child_workflow_only + end + + # Set this to true if the workflow being cancelled is a child of the workflow originating this +# command. The request will be rejected if it is set to true and the target workflow is *not* +# a child of the requesting workflow. + sig { params(value: T::Boolean).void } + def child_workflow_only=(value) + end + + # Set this to true if the workflow being cancelled is a child of the workflow originating this +# command. The request will be rejected if it is set to true and the target workflow is *not* +# a child of the requesting workflow. + sig { void } + def clear_child_workflow_only + end + + # Reason for requesting the cancellation + sig { returns(String) } + def reason + end + + # Reason for requesting the cancellation + sig { params(value: String).void } + def reason=(value) + end + + # Reason for requesting the cancellation + sig { void } + def clear_reason + 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::Command::V1::RequestCancelExternalWorkflowExecutionCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::RequestCancelExternalWorkflowExecutionCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::RequestCancelExternalWorkflowExecutionCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::RequestCancelExternalWorkflowExecutionCommandAttributes, 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::Command::V1::SignalExternalWorkflowExecutionCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + signal_name: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + control: T.nilable(String), + child_workflow_only: T.nilable(T::Boolean), + header: T.nilable(Temporalio::Api::Common::V1::Header) + ).void + end + def initialize( + namespace: "", + execution: nil, + signal_name: "", + input: nil, + control: "", + child_workflow_only: false, + header: nil + ) + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { returns(String) } + def namespace + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { params(value: String).void } + def namespace=(value) + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + sig { void } + def clear_execution + end + + # The workflow author-defined name of the signal to send to the workflow. + sig { returns(String) } + def signal_name + end + + # The workflow author-defined name of the signal to send to the workflow. + sig { params(value: String).void } + def signal_name=(value) + end + + # The workflow author-defined name of the signal to send to the workflow. + sig { void } + def clear_signal_name + end + + # Serialized value(s) to provide with the signal. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized value(s) to provide with the signal. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized value(s) to provide with the signal. + sig { void } + def clear_input + end + + # Deprecated + sig { returns(String) } + def control + end + + # Deprecated + sig { params(value: String).void } + def control=(value) + end + + # Deprecated + sig { void } + def clear_control + end + + # Set this to true if the workflow being cancelled is a child of the workflow originating this +# command. The request will be rejected if it is set to true and the target workflow is *not* +# a child of the requesting workflow. + sig { returns(T::Boolean) } + def child_workflow_only + end + + # Set this to true if the workflow being cancelled is a child of the workflow originating this +# command. The request will be rejected if it is set to true and the target workflow is *not* +# a child of the requesting workflow. + sig { params(value: T::Boolean).void } + def child_workflow_only=(value) + end + + # Set this to true if the workflow being cancelled is a child of the workflow originating this +# command. The request will be rejected if it is set to true and the target workflow is *not* +# a child of the requesting workflow. + sig { void } + def clear_child_workflow_only + end + + # Headers that are passed by the workflow that is sending a signal to the external +# workflow that is receiving this signal. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Headers that are passed by the workflow that is sending a signal to the external +# workflow that is receiving this signal. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Headers that are passed by the workflow that is sending a signal to the external +# workflow that is receiving this signal. + sig { void } + def clear_header + 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::Command::V1::SignalExternalWorkflowExecutionCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::SignalExternalWorkflowExecutionCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::SignalExternalWorkflowExecutionCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::SignalExternalWorkflowExecutionCommandAttributes, 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::Command::V1::UpsertWorkflowSearchAttributesCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes) + ).void + end + def initialize( + search_attributes: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + 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::Command::V1::UpsertWorkflowSearchAttributesCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::UpsertWorkflowSearchAttributesCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::UpsertWorkflowSearchAttributesCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::UpsertWorkflowSearchAttributesCommandAttributes, 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::Command::V1::ModifyWorkflowPropertiesCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + upserted_memo: T.nilable(Temporalio::Api::Common::V1::Memo) + ).void + end + def initialize( + upserted_memo: nil + ) + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def upserted_memo + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def upserted_memo=(value) + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { void } + def clear_upserted_memo + 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::Command::V1::ModifyWorkflowPropertiesCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::ModifyWorkflowPropertiesCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::ModifyWorkflowPropertiesCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::ModifyWorkflowPropertiesCommandAttributes, 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::Command::V1::RecordMarkerCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + marker_name: T.nilable(String), + details: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payloads)]), + header: T.nilable(Temporalio::Api::Common::V1::Header), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + marker_name: "", + details: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payloads), + header: nil, + failure: nil + ) + end + + sig { returns(String) } + def marker_name + end + + sig { params(value: String).void } + def marker_name=(value) + end + + sig { void } + def clear_marker_name + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payloads)]) } + def details + end + + sig { params(value: ::Google::Protobuf::Map).void } + def details=(value) + end + + sig { void } + def clear_details + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Command::V1::RecordMarkerCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::RecordMarkerCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::RecordMarkerCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::RecordMarkerCommandAttributes, 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::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + backoff_start_interval: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + initiator: T.nilable(T.any(Symbol, String, Integer)), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + last_completion_result: T.nilable(Temporalio::Api::Common::V1::Payloads), + cron_schedule: T.nilable(String), + header: T.nilable(Temporalio::Api::Common::V1::Header), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + inherit_build_id: T.nilable(T::Boolean), + initial_versioning_behavior: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + workflow_type: nil, + task_queue: nil, + input: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + backoff_start_interval: nil, + retry_policy: nil, + initiator: :CONTINUE_AS_NEW_INITIATOR_UNSPECIFIED, + failure: nil, + last_completion_result: nil, + cron_schedule: "", + header: nil, + memo: nil, + search_attributes: nil, + inherit_build_id: false, + initial_versioning_behavior: :CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_UNSPECIFIED + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + sig { void } + def clear_input + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # How long the workflow start will be delayed - not really a "backoff" in the traditional sense. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def backoff_start_interval + end + + # How long the workflow start will be delayed - not really a "backoff" in the traditional sense. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def backoff_start_interval=(value) + end + + # How long the workflow start will be delayed - not really a "backoff" in the traditional sense. + sig { void } + def clear_backoff_start_interval + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + sig { void } + def clear_retry_policy + end + + # Should be removed + sig { returns(T.any(Symbol, Integer)) } + def initiator + end + + # Should be removed + sig { params(value: T.any(Symbol, String, Integer)).void } + def initiator=(value) + end + + # Should be removed + sig { void } + def clear_initiator + end + + # Should be removed + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Should be removed + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Should be removed + sig { void } + def clear_failure + end + + # Should be removed + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_completion_result + end + + # Should be removed + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_completion_result=(value) + end + + # Should be removed + sig { void } + def clear_last_completion_result + end + + # Should be removed. Not necessarily unused but unclear and not exposed by SDKs. + sig { returns(String) } + def cron_schedule + end + + # Should be removed. Not necessarily unused but unclear and not exposed by SDKs. + sig { params(value: String).void } + def cron_schedule=(value) + end + + # Should be removed. Not necessarily unused but unclear and not exposed by SDKs. + sig { void } + def clear_cron_schedule + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + # If this is set, the new execution inherits the Build ID of the current execution. Otherwise, +# the assignment rules will be used to independently assign a Build ID to the new execution. +# Deprecated. Only considered for versioning v0.2. + sig { returns(T::Boolean) } + def inherit_build_id + end + + # If this is set, the new execution inherits the Build ID of the current execution. Otherwise, +# the assignment rules will be used to independently assign a Build ID to the new execution. +# Deprecated. Only considered for versioning v0.2. + sig { params(value: T::Boolean).void } + def inherit_build_id=(value) + end + + # If this is set, the new execution inherits the Build ID of the current execution. Otherwise, +# the assignment rules will be used to independently assign a Build ID to the new execution. +# Deprecated. Only considered for versioning v0.2. + sig { void } + def clear_inherit_build_id + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { returns(T.any(Symbol, Integer)) } + def initial_versioning_behavior + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { params(value: T.any(Symbol, String, Integer)).void } + def initial_versioning_behavior=(value) + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { void } + def clear_initial_versioning_behavior + 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::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes, 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::Command::V1::StartChildWorkflowExecutionCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + parent_close_policy: T.nilable(T.any(Symbol, String, Integer)), + control: T.nilable(String), + workflow_id_reuse_policy: T.nilable(T.any(Symbol, String, Integer)), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + cron_schedule: T.nilable(String), + header: T.nilable(Temporalio::Api::Common::V1::Header), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + inherit_build_id: T.nilable(T::Boolean), + priority: T.nilable(Temporalio::Api::Common::V1::Priority) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + workflow_type: nil, + task_queue: nil, + input: nil, + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + parent_close_policy: :PARENT_CLOSE_POLICY_UNSPECIFIED, + control: "", + workflow_id_reuse_policy: :WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED, + retry_policy: nil, + cron_schedule: "", + header: nil, + memo: nil, + search_attributes: nil, + inherit_build_id: false, + priority: nil + ) + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { returns(String) } + def namespace + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { params(value: String).void } + def namespace=(value) + end + + # Deprecated. Cross-namespace operations are disabled by default as of server 1.30.1. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + sig { void } + def clear_input + end + + # Total workflow execution timeout including retries and continue as new. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + # Total workflow execution timeout including retries and continue as new. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + # Total workflow execution timeout including retries and continue as new. + sig { void } + def clear_workflow_execution_timeout + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { returns(T.any(Symbol, Integer)) } + def parent_close_policy + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def parent_close_policy=(value) + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { void } + def clear_parent_close_policy + end + + sig { returns(String) } + def control + end + + sig { params(value: String).void } + def control=(value) + end + + sig { void } + def clear_control + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { returns(T.any(Symbol, Integer)) } + def workflow_id_reuse_policy + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def workflow_id_reuse_policy=(value) + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { void } + def clear_workflow_id_reuse_policy + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + sig { void } + def clear_retry_policy + end + + # Establish a cron schedule for the child workflow. + sig { returns(String) } + def cron_schedule + end + + # Establish a cron schedule for the child workflow. + sig { params(value: String).void } + def cron_schedule=(value) + end + + # Establish a cron schedule for the child workflow. + sig { void } + def clear_cron_schedule + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + # If this is set, the child workflow inherits the Build ID of the parent. Otherwise, the assignment +# rules of the child's Task Queue will be used to independently assign a Build ID to it. +# Deprecated. Only considered for versioning v0.2. + sig { returns(T::Boolean) } + def inherit_build_id + end + + # If this is set, the child workflow inherits the Build ID of the parent. Otherwise, the assignment +# rules of the child's Task Queue will be used to independently assign a Build ID to it. +# Deprecated. Only considered for versioning v0.2. + sig { params(value: T::Boolean).void } + def inherit_build_id=(value) + end + + # If this is set, the child workflow inherits the Build ID of the parent. Otherwise, the assignment +# rules of the child's Task Queue will be used to independently assign a Build ID to it. +# Deprecated. Only considered for versioning v0.2. + sig { void } + def clear_inherit_build_id + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { void } + def clear_priority + 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::Command::V1::StartChildWorkflowExecutionCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::StartChildWorkflowExecutionCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::StartChildWorkflowExecutionCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::StartChildWorkflowExecutionCommandAttributes, 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::Command::V1::ProtocolMessageCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + message_id: T.nilable(String) + ).void + end + def initialize( + message_id: "" + ) + end + + # The message ID of the message to which this command is a pointer. + sig { returns(String) } + def message_id + end + + # The message ID of the message to which this command is a pointer. + sig { params(value: String).void } + def message_id=(value) + end + + # The message ID of the message to which this command is a pointer. + sig { void } + def clear_message_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::Command::V1::ProtocolMessageCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::ProtocolMessageCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::ProtocolMessageCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::ProtocolMessageCommandAttributes, 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::Command::V1::ScheduleNexusOperationCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint: T.nilable(String), + service: T.nilable(String), + operation: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payload), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + nexus_header: T.nilable(T::Hash[String, String]), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + endpoint: "", + service: "", + operation: "", + input: nil, + schedule_to_close_timeout: nil, + nexus_header: ::Google::Protobuf::Map.new(:string, :string), + schedule_to_start_timeout: nil, + start_to_close_timeout: nil + ) + end + + # Endpoint name, must exist in the endpoint registry or this command will fail. + sig { returns(String) } + def endpoint + end + + # Endpoint name, must exist in the endpoint registry or this command will fail. + sig { params(value: String).void } + def endpoint=(value) + end + + # Endpoint name, must exist in the endpoint registry or this command will fail. + sig { void } + def clear_endpoint + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Operation name. + sig { returns(String) } + def operation + end + + # Operation name. + sig { params(value: String).void } + def operation=(value) + end + + # Operation name. + sig { void } + def clear_operation + end + + # Input for the operation. The server converts this into Nexus request content and the appropriate content headers +# internally when sending the StartOperation request. On the handler side, if it is also backed by Temporal, the +# content is transformed back to the original Payload sent in this command. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def input + end + + # Input for the operation. The server converts this into Nexus request content and the appropriate content headers +# internally when sending the StartOperation request. On the handler side, if it is also backed by Temporal, the +# content is transformed back to the original Payload sent in this command. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def input=(value) + end + + # Input for the operation. The server converts this into Nexus request content and the appropriate content headers +# internally when sending the StartOperation request. On the handler side, if it is also backed by Temporal, the +# content is transformed back to the original Payload sent in this command. + sig { void } + def clear_input + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- 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_close_timeout + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- 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_close_timeout=(value) + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in workflow history and +# transmitted to external services as-is. +# This is useful for propagating tracing information. +# Note these headers are not the same as Temporal headers on internal activities and child workflows, these are +# transmitted to Nexus operations that may be external and are not traditional payloads. + sig { returns(T::Hash[String, String]) } + def nexus_header + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in workflow history and +# transmitted to external services as-is. +# This is useful for propagating tracing information. +# Note these headers are not the same as Temporal headers on internal activities and child workflows, these are +# transmitted to Nexus operations that may be external and are not traditional payloads. + sig { params(value: ::Google::Protobuf::Map).void } + def nexus_header=(value) + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in workflow history and +# transmitted to external services as-is. +# This is useful for propagating tracing information. +# Note these headers are not the same as Temporal headers on internal activities and child workflows, these are +# transmitted to Nexus operations that may be external and are not traditional payloads. + sig { void } + def clear_nexus_header + end + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. If the operation is not started within this timeout, it will fail with +# TIMEOUT_TYPE_SCHEDULE_TO_START. +# If not set or zero, no schedule-to-start timeout is enforced. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# Requires server version 1.31.0 or later. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_start_timeout + end + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. If the operation is not started within this timeout, it will fail with +# TIMEOUT_TYPE_SCHEDULE_TO_START. +# If not set or zero, no schedule-to-start timeout is enforced. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# Requires server version 1.31.0 or later. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_start_timeout=(value) + end + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. If the operation is not started within this timeout, it will fail with +# TIMEOUT_TYPE_SCHEDULE_TO_START. +# If not set or zero, no schedule-to-start timeout is enforced. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# Requires server version 1.31.0 or later. + sig { void } + def clear_schedule_to_start_timeout + end + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. If the operation does not complete within this timeout after starting, it will fail with +# TIMEOUT_TYPE_START_TO_CLOSE. +# Only applies to asynchronous operations. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# Requires server version 1.31.0 or later. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. If the operation does not complete within this timeout after starting, it will fail with +# TIMEOUT_TYPE_START_TO_CLOSE. +# Only applies to asynchronous operations. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# Requires server version 1.31.0 or later. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def start_to_close_timeout=(value) + end + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. If the operation does not complete within this timeout after starting, it will fail with +# TIMEOUT_TYPE_START_TO_CLOSE. +# Only applies to asynchronous operations. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# Requires server version 1.31.0 or later. + sig { void } + def clear_start_to_close_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::Command::V1::ScheduleNexusOperationCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::ScheduleNexusOperationCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::ScheduleNexusOperationCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::ScheduleNexusOperationCommandAttributes, 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::Command::V1::RequestCancelNexusOperationCommandAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer) + ).void + end + def initialize( + scheduled_event_id: 0 + ) + end + + # The `NEXUS_OPERATION_SCHEDULED` event ID (a unique identifier) for the operation to be canceled. +# The operation may ignore cancellation and end up with any completion state. + sig { returns(Integer) } + def scheduled_event_id + end + + # The `NEXUS_OPERATION_SCHEDULED` event ID (a unique identifier) for the operation to be canceled. +# The operation may ignore cancellation and end up with any completion state. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The `NEXUS_OPERATION_SCHEDULED` event ID (a unique identifier) for the operation to be canceled. +# The operation may ignore cancellation and end up with any completion state. + sig { void } + def clear_scheduled_event_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::Command::V1::RequestCancelNexusOperationCommandAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::RequestCancelNexusOperationCommandAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::RequestCancelNexusOperationCommandAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::RequestCancelNexusOperationCommandAttributes, 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::Command::V1::Command + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + command_type: T.nilable(T.any(Symbol, String, Integer)), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + schedule_activity_task_command_attributes: T.nilable(Temporalio::Api::Command::V1::ScheduleActivityTaskCommandAttributes), + start_timer_command_attributes: T.nilable(Temporalio::Api::Command::V1::StartTimerCommandAttributes), + complete_workflow_execution_command_attributes: T.nilable(Temporalio::Api::Command::V1::CompleteWorkflowExecutionCommandAttributes), + fail_workflow_execution_command_attributes: T.nilable(Temporalio::Api::Command::V1::FailWorkflowExecutionCommandAttributes), + request_cancel_activity_task_command_attributes: T.nilable(Temporalio::Api::Command::V1::RequestCancelActivityTaskCommandAttributes), + cancel_timer_command_attributes: T.nilable(Temporalio::Api::Command::V1::CancelTimerCommandAttributes), + cancel_workflow_execution_command_attributes: T.nilable(Temporalio::Api::Command::V1::CancelWorkflowExecutionCommandAttributes), + request_cancel_external_workflow_execution_command_attributes: T.nilable(Temporalio::Api::Command::V1::RequestCancelExternalWorkflowExecutionCommandAttributes), + record_marker_command_attributes: T.nilable(Temporalio::Api::Command::V1::RecordMarkerCommandAttributes), + continue_as_new_workflow_execution_command_attributes: T.nilable(Temporalio::Api::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes), + start_child_workflow_execution_command_attributes: T.nilable(Temporalio::Api::Command::V1::StartChildWorkflowExecutionCommandAttributes), + signal_external_workflow_execution_command_attributes: T.nilable(Temporalio::Api::Command::V1::SignalExternalWorkflowExecutionCommandAttributes), + upsert_workflow_search_attributes_command_attributes: T.nilable(Temporalio::Api::Command::V1::UpsertWorkflowSearchAttributesCommandAttributes), + protocol_message_command_attributes: T.nilable(Temporalio::Api::Command::V1::ProtocolMessageCommandAttributes), + modify_workflow_properties_command_attributes: T.nilable(Temporalio::Api::Command::V1::ModifyWorkflowPropertiesCommandAttributes), + schedule_nexus_operation_command_attributes: T.nilable(Temporalio::Api::Command::V1::ScheduleNexusOperationCommandAttributes), + request_cancel_nexus_operation_command_attributes: T.nilable(Temporalio::Api::Command::V1::RequestCancelNexusOperationCommandAttributes) + ).void + end + def initialize( + command_type: :COMMAND_TYPE_UNSPECIFIED, + user_metadata: nil, + schedule_activity_task_command_attributes: nil, + start_timer_command_attributes: nil, + complete_workflow_execution_command_attributes: nil, + fail_workflow_execution_command_attributes: nil, + request_cancel_activity_task_command_attributes: nil, + cancel_timer_command_attributes: nil, + cancel_workflow_execution_command_attributes: nil, + request_cancel_external_workflow_execution_command_attributes: nil, + record_marker_command_attributes: nil, + continue_as_new_workflow_execution_command_attributes: nil, + start_child_workflow_execution_command_attributes: nil, + signal_external_workflow_execution_command_attributes: nil, + upsert_workflow_search_attributes_command_attributes: nil, + protocol_message_command_attributes: nil, + modify_workflow_properties_command_attributes: nil, + schedule_nexus_operation_command_attributes: nil, + request_cancel_nexus_operation_command_attributes: nil + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def command_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def command_type=(value) + end + + sig { void } + def clear_command_type + end + + # Metadata on the command. This is sometimes carried over to the history event if one is +# created as a result of the command. Most commands won't have this information, and how this +# information is used is dependent upon the interface that reads it. +# +# Current well-known uses: +# * start_child_workflow_execution_command_attributes - populates +# temporal.api.workflow.v1.WorkflowExecutionInfo.user_metadata where the summary and details +# are used by user interfaces to show fixed as-of-start workflow summary and details. +# * start_timer_command_attributes - populates temporal.api.history.v1.HistoryEvent for timer +# started where the summary is used to identify the timer. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata on the command. This is sometimes carried over to the history event if one is +# created as a result of the command. Most commands won't have this information, and how this +# information is used is dependent upon the interface that reads it. +# +# Current well-known uses: +# * start_child_workflow_execution_command_attributes - populates +# temporal.api.workflow.v1.WorkflowExecutionInfo.user_metadata where the summary and details +# are used by user interfaces to show fixed as-of-start workflow summary and details. +# * start_timer_command_attributes - populates temporal.api.history.v1.HistoryEvent for timer +# started where the summary is used to identify the timer. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata on the command. This is sometimes carried over to the history event if one is +# created as a result of the command. Most commands won't have this information, and how this +# information is used is dependent upon the interface that reads it. +# +# Current well-known uses: +# * start_child_workflow_execution_command_attributes - populates +# temporal.api.workflow.v1.WorkflowExecutionInfo.user_metadata where the summary and details +# are used by user interfaces to show fixed as-of-start workflow summary and details. +# * start_timer_command_attributes - populates temporal.api.history.v1.HistoryEvent for timer +# started where the summary is used to identify the timer. + sig { void } + def clear_user_metadata + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::ScheduleActivityTaskCommandAttributes)) } + def schedule_activity_task_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::ScheduleActivityTaskCommandAttributes)).void } + def schedule_activity_task_command_attributes=(value) + end + + sig { void } + def clear_schedule_activity_task_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::StartTimerCommandAttributes)) } + def start_timer_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::StartTimerCommandAttributes)).void } + def start_timer_command_attributes=(value) + end + + sig { void } + def clear_start_timer_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::CompleteWorkflowExecutionCommandAttributes)) } + def complete_workflow_execution_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::CompleteWorkflowExecutionCommandAttributes)).void } + def complete_workflow_execution_command_attributes=(value) + end + + sig { void } + def clear_complete_workflow_execution_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::FailWorkflowExecutionCommandAttributes)) } + def fail_workflow_execution_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::FailWorkflowExecutionCommandAttributes)).void } + def fail_workflow_execution_command_attributes=(value) + end + + sig { void } + def clear_fail_workflow_execution_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::RequestCancelActivityTaskCommandAttributes)) } + def request_cancel_activity_task_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::RequestCancelActivityTaskCommandAttributes)).void } + def request_cancel_activity_task_command_attributes=(value) + end + + sig { void } + def clear_request_cancel_activity_task_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::CancelTimerCommandAttributes)) } + def cancel_timer_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::CancelTimerCommandAttributes)).void } + def cancel_timer_command_attributes=(value) + end + + sig { void } + def clear_cancel_timer_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::CancelWorkflowExecutionCommandAttributes)) } + def cancel_workflow_execution_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::CancelWorkflowExecutionCommandAttributes)).void } + def cancel_workflow_execution_command_attributes=(value) + end + + sig { void } + def clear_cancel_workflow_execution_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::RequestCancelExternalWorkflowExecutionCommandAttributes)) } + def request_cancel_external_workflow_execution_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::RequestCancelExternalWorkflowExecutionCommandAttributes)).void } + def request_cancel_external_workflow_execution_command_attributes=(value) + end + + sig { void } + def clear_request_cancel_external_workflow_execution_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::RecordMarkerCommandAttributes)) } + def record_marker_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::RecordMarkerCommandAttributes)).void } + def record_marker_command_attributes=(value) + end + + sig { void } + def clear_record_marker_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes)) } + def continue_as_new_workflow_execution_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::ContinueAsNewWorkflowExecutionCommandAttributes)).void } + def continue_as_new_workflow_execution_command_attributes=(value) + end + + sig { void } + def clear_continue_as_new_workflow_execution_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::StartChildWorkflowExecutionCommandAttributes)) } + def start_child_workflow_execution_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::StartChildWorkflowExecutionCommandAttributes)).void } + def start_child_workflow_execution_command_attributes=(value) + end + + sig { void } + def clear_start_child_workflow_execution_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::SignalExternalWorkflowExecutionCommandAttributes)) } + def signal_external_workflow_execution_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::SignalExternalWorkflowExecutionCommandAttributes)).void } + def signal_external_workflow_execution_command_attributes=(value) + end + + sig { void } + def clear_signal_external_workflow_execution_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::UpsertWorkflowSearchAttributesCommandAttributes)) } + def upsert_workflow_search_attributes_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::UpsertWorkflowSearchAttributesCommandAttributes)).void } + def upsert_workflow_search_attributes_command_attributes=(value) + end + + sig { void } + def clear_upsert_workflow_search_attributes_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::ProtocolMessageCommandAttributes)) } + def protocol_message_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::ProtocolMessageCommandAttributes)).void } + def protocol_message_command_attributes=(value) + end + + sig { void } + def clear_protocol_message_command_attributes + end + + # 16 is available for use - it was used as part of a prototype that never made it into a release + sig { returns(T.nilable(Temporalio::Api::Command::V1::ModifyWorkflowPropertiesCommandAttributes)) } + def modify_workflow_properties_command_attributes + end + + # 16 is available for use - it was used as part of a prototype that never made it into a release + sig { params(value: T.nilable(Temporalio::Api::Command::V1::ModifyWorkflowPropertiesCommandAttributes)).void } + def modify_workflow_properties_command_attributes=(value) + end + + # 16 is available for use - it was used as part of a prototype that never made it into a release + sig { void } + def clear_modify_workflow_properties_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::ScheduleNexusOperationCommandAttributes)) } + def schedule_nexus_operation_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::ScheduleNexusOperationCommandAttributes)).void } + def schedule_nexus_operation_command_attributes=(value) + end + + sig { void } + def clear_schedule_nexus_operation_command_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Command::V1::RequestCancelNexusOperationCommandAttributes)) } + def request_cancel_nexus_operation_command_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Command::V1::RequestCancelNexusOperationCommandAttributes)).void } + def request_cancel_nexus_operation_command_attributes=(value) + end + + sig { void } + def clear_request_cancel_nexus_operation_command_attributes + end + + sig { returns(T.nilable(Symbol)) } + def attributes + 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::Command::V1::Command) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Command::V1::Command).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Command::V1::Command) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Command::V1::Command, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/common/v1/grpc_status.rbi b/temporalio/rbi/temporalio/api/common/v1/grpc_status.rbi new file mode 100644 index 00000000..d0cbb771 --- /dev/null +++ b/temporalio/rbi/temporalio/api/common/v1/grpc_status.rbi @@ -0,0 +1,92 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/common/v1/grpc_status.proto +# typed: strict + +# From https://github.com/grpc/grpc/blob/master/src/proto/grpc/status/status.proto +# since we don't import grpc but still need the status info +class Temporalio::Api::Common::V1::GrpcStatus + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + code: T.nilable(Integer), + message: T.nilable(String), + details: T.nilable(T::Array[T.nilable(Google::Protobuf::Any)]) + ).void + end + def initialize( + code: 0, + message: "", + details: [] + ) + end + + sig { returns(Integer) } + def code + end + + sig { params(value: Integer).void } + def code=(value) + end + + sig { void } + def clear_code + end + + sig { returns(String) } + def message + end + + sig { params(value: String).void } + def message=(value) + end + + sig { void } + def clear_message + end + + sig { returns(T::Array[T.nilable(Google::Protobuf::Any)]) } + def details + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def details=(value) + end + + sig { void } + def clear_details + 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::GrpcStatus) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::GrpcStatus).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::GrpcStatus) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::GrpcStatus, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/common/v1/message.rbi b/temporalio/rbi/temporalio/api/common/v1/message.rbi new file mode 100644 index 00000000..8c76019b --- /dev/null +++ b/temporalio/rbi/temporalio/api/common/v1/message.rbi @@ -0,0 +1,2633 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/common/v1/message.proto +# typed: strict + +class Temporalio::Api::Common::V1::DataBlob + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + encoding_type: T.nilable(T.any(Symbol, String, Integer)), + data: T.nilable(String) + ).void + end + def initialize( + encoding_type: :ENCODING_TYPE_UNSPECIFIED, + data: "" + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def encoding_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def encoding_type=(value) + end + + sig { void } + def clear_encoding_type + end + + sig { returns(String) } + def data + end + + sig { params(value: String).void } + def data=(value) + end + + sig { void } + def clear_data + 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::DataBlob) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::DataBlob).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::DataBlob) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::DataBlob, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# See `Payload` +class Temporalio::Api::Common::V1::Payloads + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + payloads: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + payloads: [] + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def payloads + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def payloads=(value) + end + + sig { void } + def clear_payloads + 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::Payloads) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Payloads).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Payloads) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Payloads, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Represents some binary (byte array) data (ex: activity input parameters or workflow result) with +# metadata which describes this binary data (format, encoding, encryption, etc). Serialization +# of the data may be user-defined. +class Temporalio::Api::Common::V1::Payload + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + metadata: T.nilable(T::Hash[String, String]), + data: T.nilable(String), + external_payloads: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload::ExternalPayloadDetails)]) + ).void + end + def initialize( + metadata: ::Google::Protobuf::Map.new(:string, :bytes), + data: "", + external_payloads: [] + ) + end + + sig { returns(T::Hash[String, String]) } + def metadata + end + + sig { params(value: ::Google::Protobuf::Map).void } + def metadata=(value) + end + + sig { void } + def clear_metadata + end + + sig { returns(String) } + def data + end + + sig { params(value: String).void } + def data=(value) + end + + sig { void } + def clear_data + end + + # Details about externally stored payloads associated with this payload. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload::ExternalPayloadDetails)]) } + def external_payloads + end + + # Details about externally stored payloads associated with this payload. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def external_payloads=(value) + end + + # Details about externally stored payloads associated with this payload. + sig { void } + def clear_external_payloads + 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::Payload) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Payload).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Payload) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Payload, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A user-defined set of *indexed* fields that are used/exposed when listing/searching workflows. +# The payload is not serialized in a user-defined way. +class Temporalio::Api::Common::V1::SearchAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + indexed_fields: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + indexed_fields: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload) + ) + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def indexed_fields + end + + sig { params(value: ::Google::Protobuf::Map).void } + def indexed_fields=(value) + end + + sig { void } + def clear_indexed_fields + 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::SearchAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::SearchAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::SearchAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::SearchAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A user-defined set of *unindexed* fields that are exposed when listing/searching workflows +class Temporalio::Api::Common::V1::Memo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + fields: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + fields: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload) + ) + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def fields + end + + sig { params(value: ::Google::Protobuf::Map).void } + def fields=(value) + end + + sig { void } + def clear_fields + 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::Memo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Memo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Memo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Memo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Contains metadata that can be attached to a variety of requests, like starting a workflow, and +# can be propagated between, for example, workflows and activities. +class Temporalio::Api::Common::V1::Header + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + fields: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + fields: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload) + ) + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def fields + end + + sig { params(value: ::Google::Protobuf::Map).void } + def fields=(value) + end + + sig { void } + def clear_fields + 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::Header) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Header).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Header) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Header, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Identifies a specific workflow within a namespace. Practically speaking, because run_id is a +# uuid, a workflow execution is globally unique. Note that many commands allow specifying an empty +# run id as a way of saying "target the latest run of the workflow". +class Temporalio::Api::Common::V1::WorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + workflow_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Common::V1::WorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::WorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Represents the identifier used by a workflow author to define the workflow. Typically, the +# name of a function. This is sometimes referred to as the workflow's "name" +class Temporalio::Api::Common::V1::WorkflowType + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String) + ).void + end + def initialize( + name: "" + ) + end + + sig { returns(String) } + def name + end + + sig { params(value: String).void } + def name=(value) + end + + sig { void } + def clear_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::Common::V1::WorkflowType) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkflowType).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::WorkflowType) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkflowType, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Represents the identifier used by a activity author to define the activity. Typically, the +# name of a function. This is sometimes referred to as the activity's "name" +class Temporalio::Api::Common::V1::ActivityType + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String) + ).void + end + def initialize( + name: "" + ) + end + + sig { returns(String) } + def name + end + + sig { params(value: String).void } + def name=(value) + end + + sig { void } + def clear_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::Common::V1::ActivityType) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::ActivityType).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::ActivityType) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::ActivityType, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# How retries ought to be handled, usable by both workflows and activities +class Temporalio::Api::Common::V1::RetryPolicy + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + initial_interval: T.nilable(Google::Protobuf::Duration), + backoff_coefficient: T.nilable(Float), + maximum_interval: T.nilable(Google::Protobuf::Duration), + maximum_attempts: T.nilable(Integer), + non_retryable_error_types: T.nilable(T::Array[String]) + ).void + end + def initialize( + initial_interval: nil, + backoff_coefficient: 0.0, + maximum_interval: nil, + maximum_attempts: 0, + non_retryable_error_types: [] + ) + end + + # Interval of the first retry. If retryBackoffCoefficient is 1.0 then it is used for all retries. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def initial_interval + end + + # Interval of the first retry. If retryBackoffCoefficient is 1.0 then it is used for all retries. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def initial_interval=(value) + end + + # Interval of the first retry. If retryBackoffCoefficient is 1.0 then it is used for all retries. + sig { void } + def clear_initial_interval + end + + # Coefficient used to calculate the next retry interval. +# The next retry interval is previous interval multiplied by the coefficient. +# Must be 1 or larger. + sig { returns(Float) } + def backoff_coefficient + end + + # Coefficient used to calculate the next retry interval. +# The next retry interval is previous interval multiplied by the coefficient. +# Must be 1 or larger. + sig { params(value: Float).void } + def backoff_coefficient=(value) + end + + # Coefficient used to calculate the next retry interval. +# The next retry interval is previous interval multiplied by the coefficient. +# Must be 1 or larger. + sig { void } + def clear_backoff_coefficient + end + + # Maximum interval between retries. Exponential backoff leads to interval increase. +# This value is the cap of the increase. Default is 100x of the initial interval. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def maximum_interval + end + + # Maximum interval between retries. Exponential backoff leads to interval increase. +# This value is the cap of the increase. Default is 100x of the initial interval. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def maximum_interval=(value) + end + + # Maximum interval between retries. Exponential backoff leads to interval increase. +# This value is the cap of the increase. Default is 100x of the initial interval. + sig { void } + def clear_maximum_interval + end + + # Maximum number of attempts. When exceeded the retries stop even if not expired yet. +# 1 disables retries. 0 means unlimited (up to the timeouts) + sig { returns(Integer) } + def maximum_attempts + end + + # Maximum number of attempts. When exceeded the retries stop even if not expired yet. +# 1 disables retries. 0 means unlimited (up to the timeouts) + sig { params(value: Integer).void } + def maximum_attempts=(value) + end + + # Maximum number of attempts. When exceeded the retries stop even if not expired yet. +# 1 disables retries. 0 means unlimited (up to the timeouts) + sig { void } + def clear_maximum_attempts + end + + # Non-Retryable errors types. Will stop retrying if the error type matches this list. Note that +# this is not a substring match, the error *type* (not message) must match exactly. + sig { returns(T::Array[String]) } + def non_retryable_error_types + end + + # Non-Retryable errors types. Will stop retrying if the error type matches this list. Note that +# this is not a substring match, the error *type* (not message) must match exactly. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def non_retryable_error_types=(value) + end + + # Non-Retryable errors types. Will stop retrying if the error type matches this list. Note that +# this is not a substring match, the error *type* (not message) must match exactly. + sig { void } + def clear_non_retryable_error_types + 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::RetryPolicy) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::RetryPolicy).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::RetryPolicy) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::RetryPolicy, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Metadata relevant for metering purposes +class Temporalio::Api::Common::V1::MeteringMetadata + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + nonfirst_local_activity_execution_attempts: T.nilable(Integer) + ).void + end + def initialize( + nonfirst_local_activity_execution_attempts: 0 + ) + end + + # Count of local activities which have begun an execution attempt during this workflow task, +# and whose first attempt occurred in some previous task. This is used for metering +# purposes, and does not affect workflow state. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: Negative values make no sense to represent. --) + sig { returns(Integer) } + def nonfirst_local_activity_execution_attempts + end + + # Count of local activities which have begun an execution attempt during this workflow task, +# and whose first attempt occurred in some previous task. This is used for metering +# purposes, and does not affect workflow state. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: Negative values make no sense to represent. --) + sig { params(value: Integer).void } + def nonfirst_local_activity_execution_attempts=(value) + end + + # Count of local activities which have begun an execution attempt during this workflow task, +# and whose first attempt occurred in some previous task. This is used for metering +# purposes, and does not affect workflow state. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: Negative values make no sense to represent. --) + sig { void } + def clear_nonfirst_local_activity_execution_attempts + 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::MeteringMetadata) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::MeteringMetadata).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::MeteringMetadata) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::MeteringMetadata, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Deprecated. This message is replaced with `Deployment` and `VersioningBehavior`. +# Identifies the version(s) of a worker that processed a task +class Temporalio::Api::Common::V1::WorkerVersionStamp + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + build_id: T.nilable(String), + use_versioning: T.nilable(T::Boolean) + ).void + end + def initialize( + build_id: "", + use_versioning: false + ) + end + + # An opaque whole-worker identifier. Replaces the deprecated `binary_checksum` field when this +# message is included in requests which previously used that. + sig { returns(String) } + def build_id + end + + # An opaque whole-worker identifier. Replaces the deprecated `binary_checksum` field when this +# message is included in requests which previously used that. + sig { params(value: String).void } + def build_id=(value) + end + + # An opaque whole-worker identifier. Replaces the deprecated `binary_checksum` field when this +# message is included in requests which previously used that. + sig { void } + def clear_build_id + end + + # If set, the worker is opting in to worker versioning. Otherwise, this is used only as a +# marker for workflow reset points and the BuildIDs search attribute. + sig { returns(T::Boolean) } + def use_versioning + end + + # If set, the worker is opting in to worker versioning. Otherwise, this is used only as a +# marker for workflow reset points and the BuildIDs search attribute. + sig { params(value: T::Boolean).void } + def use_versioning=(value) + end + + # If set, the worker is opting in to worker versioning. Otherwise, this is used only as a +# marker for workflow reset points and the BuildIDs search attribute. + sig { void } + def clear_use_versioning + 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::WorkerVersionStamp) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkerVersionStamp).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::WorkerVersionStamp) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkerVersionStamp, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Identifies the version that a worker is compatible with when polling or identifying itself, +# and whether or not this worker is opting into the build-id based versioning feature. This is +# used by matching to determine which workers ought to receive what tasks. +# Deprecated. Use WorkerDeploymentOptions instead. +class Temporalio::Api::Common::V1::WorkerVersionCapabilities + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + build_id: T.nilable(String), + use_versioning: T.nilable(T::Boolean), + deployment_series_name: T.nilable(String) + ).void + end + def initialize( + build_id: "", + use_versioning: false, + deployment_series_name: "" + ) + end + + # An opaque whole-worker identifier + sig { returns(String) } + def build_id + end + + # An opaque whole-worker identifier + sig { params(value: String).void } + def build_id=(value) + end + + # An opaque whole-worker identifier + sig { void } + def clear_build_id + end + + # If set, the worker is opting in to worker versioning, and wishes to only receive appropriate +# tasks. + sig { returns(T::Boolean) } + def use_versioning + end + + # If set, the worker is opting in to worker versioning, and wishes to only receive appropriate +# tasks. + sig { params(value: T::Boolean).void } + def use_versioning=(value) + end + + # If set, the worker is opting in to worker versioning, and wishes to only receive appropriate +# tasks. + sig { void } + def clear_use_versioning + end + + # Must be sent if user has set a deployment series name (versioning-3). + sig { returns(String) } + def deployment_series_name + end + + # Must be sent if user has set a deployment series name (versioning-3). + sig { params(value: String).void } + def deployment_series_name=(value) + end + + # Must be sent if user has set a deployment series name (versioning-3). + sig { void } + def clear_deployment_series_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::Common::V1::WorkerVersionCapabilities) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkerVersionCapabilities).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::WorkerVersionCapabilities) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkerVersionCapabilities, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Describes where and how to reset a workflow, used for batch reset currently +# and may be used for single-workflow reset later. +class Temporalio::Api::Common::V1::ResetOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + first_workflow_task: T.nilable(Google::Protobuf::Empty), + last_workflow_task: T.nilable(Google::Protobuf::Empty), + workflow_task_id: T.nilable(Integer), + build_id: T.nilable(String), + reset_reapply_type: T.nilable(T.any(Symbol, String, Integer)), + current_run_only: T.nilable(T::Boolean), + reset_reapply_exclude_types: T.nilable(T::Array[T.any(Symbol, String, Integer)]) + ).void + end + def initialize( + first_workflow_task: nil, + last_workflow_task: nil, + workflow_task_id: 0, + build_id: "", + reset_reapply_type: :RESET_REAPPLY_TYPE_UNSPECIFIED, + current_run_only: false, + reset_reapply_exclude_types: [] + ) + end + + # Resets to the first workflow task completed or started event. + sig { returns(T.nilable(Google::Protobuf::Empty)) } + def first_workflow_task + end + + # Resets to the first workflow task completed or started event. + sig { params(value: T.nilable(Google::Protobuf::Empty)).void } + def first_workflow_task=(value) + end + + # Resets to the first workflow task completed or started event. + sig { void } + def clear_first_workflow_task + end + + # Resets to the last workflow task completed or started event. + sig { returns(T.nilable(Google::Protobuf::Empty)) } + def last_workflow_task + end + + # Resets to the last workflow task completed or started event. + sig { params(value: T.nilable(Google::Protobuf::Empty)).void } + def last_workflow_task=(value) + end + + # Resets to the last workflow task completed or started event. + sig { void } + def clear_last_workflow_task + end + + # The id of a specific `WORKFLOW_TASK_COMPLETED`,`WORKFLOW_TASK_TIMED_OUT`, `WORKFLOW_TASK_FAILED`, or +# `WORKFLOW_TASK_STARTED` event to reset to. +# Note that this option doesn't make sense when used as part of a batch request. + sig { returns(Integer) } + def workflow_task_id + end + + # The id of a specific `WORKFLOW_TASK_COMPLETED`,`WORKFLOW_TASK_TIMED_OUT`, `WORKFLOW_TASK_FAILED`, or +# `WORKFLOW_TASK_STARTED` event to reset to. +# Note that this option doesn't make sense when used as part of a batch request. + sig { params(value: Integer).void } + def workflow_task_id=(value) + end + + # The id of a specific `WORKFLOW_TASK_COMPLETED`,`WORKFLOW_TASK_TIMED_OUT`, `WORKFLOW_TASK_FAILED`, or +# `WORKFLOW_TASK_STARTED` event to reset to. +# Note that this option doesn't make sense when used as part of a batch request. + sig { void } + def clear_workflow_task_id + end + + # Resets to the first workflow task processed by this build id. +# If the workflow was not processed by the build id, or the workflow task can't be +# determined, no reset will be performed. +# Note that by default, this reset is allowed to be to a prior run in a chain of +# continue-as-new. + sig { returns(String) } + def build_id + end + + # Resets to the first workflow task processed by this build id. +# If the workflow was not processed by the build id, or the workflow task can't be +# determined, no reset will be performed. +# Note that by default, this reset is allowed to be to a prior run in a chain of +# continue-as-new. + sig { params(value: String).void } + def build_id=(value) + end + + # Resets to the first workflow task processed by this build id. +# If the workflow was not processed by the build id, or the workflow task can't be +# determined, no reset will be performed. +# Note that by default, this reset is allowed to be to a prior run in a chain of +# continue-as-new. + sig { void } + def clear_build_id + end + + # Deprecated. Use `options`. +# Default: RESET_REAPPLY_TYPE_SIGNAL + sig { returns(T.any(Symbol, Integer)) } + def reset_reapply_type + end + + # Deprecated. Use `options`. +# Default: RESET_REAPPLY_TYPE_SIGNAL + sig { params(value: T.any(Symbol, String, Integer)).void } + def reset_reapply_type=(value) + end + + # Deprecated. Use `options`. +# Default: RESET_REAPPLY_TYPE_SIGNAL + sig { void } + def clear_reset_reapply_type + end + + # If true, limit the reset to only within the current run. (Applies to build_id targets and +# possibly others in the future.) + sig { returns(T::Boolean) } + def current_run_only + end + + # If true, limit the reset to only within the current run. (Applies to build_id targets and +# possibly others in the future.) + sig { params(value: T::Boolean).void } + def current_run_only=(value) + end + + # If true, limit the reset to only within the current run. (Applies to build_id targets and +# possibly others in the future.) + sig { void } + def clear_current_run_only + end + + # Event types not to be reapplied + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def reset_reapply_exclude_types + end + + # Event types not to be reapplied + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def reset_reapply_exclude_types=(value) + end + + # Event types not to be reapplied + sig { void } + def clear_reset_reapply_exclude_types + end + + sig { returns(T.nilable(Symbol)) } + def target + 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::ResetOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::ResetOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::ResetOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::ResetOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Callback to attach to various events in the system, e.g. workflow run completion. +class Temporalio::Api::Common::V1::Callback + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + nexus: T.nilable(Temporalio::Api::Common::V1::Callback::Nexus), + internal: T.nilable(Temporalio::Api::Common::V1::Callback::Internal), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) + ).void + end + def initialize( + nexus: nil, + internal: nil, + links: [] + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Callback::Nexus)) } + def nexus + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Callback::Nexus)).void } + def nexus=(value) + end + + sig { void } + def clear_nexus + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Callback::Internal)) } + def internal + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Callback::Internal)).void } + def internal=(value) + end + + sig { void } + def clear_internal + end + + # Links associated with the callback. It can be used to link to underlying resources of the +# callback. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links associated with the callback. It can be used to link to underlying resources of the +# callback. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links associated with the callback. It can be used to link to underlying resources of the +# callback. + sig { void } + def clear_links + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Callback) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Callback).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Callback) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Callback, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Link can be associated with history events. It might contain information about an external entity +# related to the history event. For example, workflow A makes a Nexus call that starts workflow B: +# in this case, a history event in workflow A could contain a Link to the workflow started event in +# workflow B, and vice-versa. +class Temporalio::Api::Common::V1::Link + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_event: T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent), + batch_job: T.nilable(Temporalio::Api::Common::V1::Link::BatchJob), + activity: T.nilable(Temporalio::Api::Common::V1::Link::Activity), + nexus_operation: T.nilable(Temporalio::Api::Common::V1::Link::NexusOperation) + ).void + end + def initialize( + workflow_event: nil, + batch_job: nil, + activity: nil, + nexus_operation: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent)) } + def workflow_event + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent)).void } + def workflow_event=(value) + end + + sig { void } + def clear_workflow_event + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link::BatchJob)) } + def batch_job + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link::BatchJob)).void } + def batch_job=(value) + end + + sig { void } + def clear_batch_job + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link::Activity)) } + def activity + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link::Activity)).void } + def activity=(value) + end + + sig { void } + def clear_activity + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link::NexusOperation)) } + def nexus_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link::NexusOperation)).void } + def nexus_operation=(value) + end + + sig { void } + def clear_nexus_operation + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Link) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Link) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Principal is an authenticated caller identity computed by the server from trusted +# authentication context. +class Temporalio::Api::Common::V1::Principal + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(String), + name: T.nilable(String) + ).void + end + def initialize( + type: "", + name: "" + ) + 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). + sig { returns(String) } + def name + end + + # Identifier within that category (e.g., sub JWT claim, email address). + sig { params(value: String).void } + def name=(value) + end + + # Identifier within that category (e.g., sub JWT claim, email address). + sig { void } + def clear_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::Common::V1::Principal) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Principal).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Principal) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Principal, 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 +# task queues and in rate limiting decisions. +# +# Priority is attached to workflows and activities. By default, activities +# inherit Priority from the workflow that created them, but may override fields +# when an activity is started or modified. +# +# Despite being named "Priority", this message also contains fields that +# control "fairness" mechanisms. +# +# For all fields, the field not present or equal to zero/empty string means to +# inherit the value from the calling workflow, or if there is no calling +# workflow, then use the default value. +# +# For all fields other than fairness_key, the zero value isn't meaningful so +# there's no confusion between inherit/default and a meaningful value. For +# fairness_key, the empty string will be interpreted as "inherit". This means +# that if a workflow has a non-empty fairness key, you can't override the +# fairness key of its activity to the empty string. +# +# The overall semantics of Priority are: +# 1. First, consider "priority": higher priority (lower number) goes first. +# 2. Then, consider fairness: try to dispatch tasks for different fairness keys +# in proportion to their weight. +# +# Applications may use any subset of mechanisms that are useful to them and +# leave the other fields to use default values. +# +# Not all queues in the system may support the "full" semantics of all priority +# fields. (Currently only support in matching task queues is planned.) +class Temporalio::Api::Common::V1::Priority + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + priority_key: T.nilable(Integer), + fairness_key: T.nilable(String), + fairness_weight: T.nilable(Float) + ).void + end + def initialize( + priority_key: 0, + fairness_key: "", + fairness_weight: 0.0 + ) + end + + # Priority key is a positive integer from 1 to n, where smaller integers +# correspond to higher priorities (tasks run sooner). In general, tasks in +# a queue should be processed in close to priority order, although small +# deviations are possible. +# +# The maximum priority value (minimum priority) is determined by server +# configuration, and defaults to 5. +# +# If priority is not present (or zero), then the effective priority will be +# the default priority, which is calculated by (min+max)/2. With the +# default max of 5, and min of 1, that comes out to 3. + sig { returns(Integer) } + def priority_key + end + + # Priority key is a positive integer from 1 to n, where smaller integers +# correspond to higher priorities (tasks run sooner). In general, tasks in +# a queue should be processed in close to priority order, although small +# deviations are possible. +# +# The maximum priority value (minimum priority) is determined by server +# configuration, and defaults to 5. +# +# If priority is not present (or zero), then the effective priority will be +# the default priority, which is calculated by (min+max)/2. With the +# default max of 5, and min of 1, that comes out to 3. + sig { params(value: Integer).void } + def priority_key=(value) + end + + # Priority key is a positive integer from 1 to n, where smaller integers +# correspond to higher priorities (tasks run sooner). In general, tasks in +# a queue should be processed in close to priority order, although small +# deviations are possible. +# +# The maximum priority value (minimum priority) is determined by server +# configuration, and defaults to 5. +# +# If priority is not present (or zero), then the effective priority will be +# the default priority, which is calculated by (min+max)/2. With the +# default max of 5, and min of 1, that comes out to 3. + sig { void } + def clear_priority_key + end + + # Fairness key is a short string that's used as a key for a fairness +# balancing mechanism. It may correspond to a tenant id, or to a fixed +# string like "high" or "low". The default is the empty string. +# +# The fairness mechanism attempts to dispatch tasks for a given key in +# proportion to its weight. For example, using a thousand distinct tenant +# ids, each with a weight of 1.0 (the default) will result in each tenant +# getting a roughly equal share of task dispatch throughput. +# +# (Note: this does not imply equal share of worker capacity! Fairness +# decisions are made based on queue statistics, not +# current worker load.) +# +# As another example, using keys "high" and "low" with weight 9.0 and 1.0 +# respectively will prefer dispatching "high" tasks over "low" tasks at a +# 9:1 ratio, while allowing either key to use all worker capacity if the +# other is not present. +# +# All fairness mechanisms, including rate limits, are best-effort and +# probabilistic. The results may not match what a "perfect" algorithm with +# infinite resources would produce. The more unique keys are used, the less +# accurate the results will be. +# +# Fairness keys are limited to 64 bytes. + sig { returns(String) } + def fairness_key + end + + # Fairness key is a short string that's used as a key for a fairness +# balancing mechanism. It may correspond to a tenant id, or to a fixed +# string like "high" or "low". The default is the empty string. +# +# The fairness mechanism attempts to dispatch tasks for a given key in +# proportion to its weight. For example, using a thousand distinct tenant +# ids, each with a weight of 1.0 (the default) will result in each tenant +# getting a roughly equal share of task dispatch throughput. +# +# (Note: this does not imply equal share of worker capacity! Fairness +# decisions are made based on queue statistics, not +# current worker load.) +# +# As another example, using keys "high" and "low" with weight 9.0 and 1.0 +# respectively will prefer dispatching "high" tasks over "low" tasks at a +# 9:1 ratio, while allowing either key to use all worker capacity if the +# other is not present. +# +# All fairness mechanisms, including rate limits, are best-effort and +# probabilistic. The results may not match what a "perfect" algorithm with +# infinite resources would produce. The more unique keys are used, the less +# accurate the results will be. +# +# Fairness keys are limited to 64 bytes. + sig { params(value: String).void } + def fairness_key=(value) + end + + # Fairness key is a short string that's used as a key for a fairness +# balancing mechanism. It may correspond to a tenant id, or to a fixed +# string like "high" or "low". The default is the empty string. +# +# The fairness mechanism attempts to dispatch tasks for a given key in +# proportion to its weight. For example, using a thousand distinct tenant +# ids, each with a weight of 1.0 (the default) will result in each tenant +# getting a roughly equal share of task dispatch throughput. +# +# (Note: this does not imply equal share of worker capacity! Fairness +# decisions are made based on queue statistics, not +# current worker load.) +# +# As another example, using keys "high" and "low" with weight 9.0 and 1.0 +# respectively will prefer dispatching "high" tasks over "low" tasks at a +# 9:1 ratio, while allowing either key to use all worker capacity if the +# other is not present. +# +# All fairness mechanisms, including rate limits, are best-effort and +# probabilistic. The results may not match what a "perfect" algorithm with +# infinite resources would produce. The more unique keys are used, the less +# accurate the results will be. +# +# Fairness keys are limited to 64 bytes. + sig { void } + def clear_fairness_key + end + + # Fairness weight for a task can come from multiple sources for +# flexibility. From highest to lowest precedence: +# 1. Weights for a small set of keys can be overridden in task queue +# configuration with an API. +# 2. It can be attached to the workflow/activity in this field. +# 3. The default weight of 1.0 will be used. +# +# Weight values are clamped to the range [0.001, 1000]. + sig { returns(Float) } + def fairness_weight + end + + # Fairness weight for a task can come from multiple sources for +# flexibility. From highest to lowest precedence: +# 1. Weights for a small set of keys can be overridden in task queue +# configuration with an API. +# 2. It can be attached to the workflow/activity in this field. +# 3. The default weight of 1.0 will be used. +# +# Weight values are clamped to the range [0.001, 1000]. + sig { params(value: Float).void } + def fairness_weight=(value) + end + + # Fairness weight for a task can come from multiple sources for +# flexibility. From highest to lowest precedence: +# 1. Weights for a small set of keys can be overridden in task queue +# configuration with an API. +# 2. It can be attached to the workflow/activity in this field. +# 3. The default weight of 1.0 will be used. +# +# Weight values are clamped to the range [0.001, 1000]. + sig { void } + def clear_fairness_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::Common::V1::Priority) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Priority).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Priority) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Priority, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# This is used to send commands to a specific worker or a group of workers. +# Right now, it is used to send commands to a specific worker instance. +# Will be extended to be able to send command to multiple workers. +class Temporalio::Api::Common::V1::WorkerSelector + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_instance_key: T.nilable(String) + ).void + end + def initialize( + worker_instance_key: "" + ) + end + + # Worker instance key to which the command should be sent. + sig { returns(String) } + def worker_instance_key + end + + # Worker instance key to which the command should be sent. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # Worker instance key to which the command should be sent. + sig { void } + def clear_worker_instance_key + end + + sig { returns(T.nilable(Symbol)) } + def selector + 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::WorkerSelector) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkerSelector).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::WorkerSelector) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::WorkerSelector, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# When starting an execution with a conflict policy that uses an existing execution and there is already an existing +# running execution, OnConflictOptions defines actions to be taken on the existing running execution. +class Temporalio::Api::Common::V1::OnConflictOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + attach_request_id: T.nilable(T::Boolean), + attach_completion_callbacks: T.nilable(T::Boolean), + attach_links: T.nilable(T::Boolean) + ).void + end + def initialize( + attach_request_id: false, + attach_completion_callbacks: false, + attach_links: false + ) + end + + # Attaches the request ID to the running execution. + sig { returns(T::Boolean) } + def attach_request_id + end + + # Attaches the request ID to the running execution. + sig { params(value: T::Boolean).void } + def attach_request_id=(value) + end + + # Attaches the request ID to the running execution. + sig { void } + def clear_attach_request_id + end + + # Attaches the completion callbacks to the running execution. + sig { returns(T::Boolean) } + def attach_completion_callbacks + end + + # Attaches the completion callbacks to the running execution. + sig { params(value: T::Boolean).void } + def attach_completion_callbacks=(value) + end + + # Attaches the completion callbacks to the running execution. + sig { void } + def clear_attach_completion_callbacks + end + + # Attaches the links to the running execution. + sig { returns(T::Boolean) } + def attach_links + end + + # Attaches the links to the running execution. + sig { params(value: T::Boolean).void } + def attach_links=(value) + end + + # Attaches the links to the running execution. + sig { void } + def clear_attach_links + 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::OnConflictOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::OnConflictOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::OnConflictOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::OnConflictOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Describes an externally stored object referenced by this payload. +class Temporalio::Api::Common::V1::Payload::ExternalPayloadDetails + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + size_bytes: T.nilable(Integer) + ).void + end + def initialize( + size_bytes: 0 + ) + end + + # Size in bytes of the externally stored payload + sig { returns(Integer) } + def size_bytes + end + + # Size in bytes of the externally stored payload + sig { params(value: Integer).void } + def size_bytes=(value) + end + + # Size in bytes of the externally stored payload + sig { void } + def clear_size_bytes + 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::Payload::ExternalPayloadDetails) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Payload::ExternalPayloadDetails).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Payload::ExternalPayloadDetails) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Payload::ExternalPayloadDetails, 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::Common::V1::Callback::Nexus + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + url: T.nilable(String), + header: T.nilable(T::Hash[String, String]) + ).void + end + def initialize( + url: "", + header: ::Google::Protobuf::Map.new(:string, :string) + ) + end + + # Callback URL. + sig { returns(String) } + def url + end + + # Callback URL. + sig { params(value: String).void } + def url=(value) + end + + # Callback URL. + sig { void } + def clear_url + end + + # Header to attach to callback request. + sig { returns(T::Hash[String, String]) } + def header + end + + # Header to attach to callback request. + sig { params(value: ::Google::Protobuf::Map).void } + def header=(value) + end + + # Header to attach to callback request. + sig { void } + def clear_header + 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::Callback::Nexus) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Callback::Nexus).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Callback::Nexus) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Callback::Nexus, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Callbacks to be delivered internally within the system. +# This variant is not settable in the API and will be rejected by the service with an INVALID_ARGUMENT error. +# The only reason that this is exposed is because callbacks are replicated across clusters via the +# WorkflowExecutionStarted event, which is defined in the public API. +class Temporalio::Api::Common::V1::Callback::Internal + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + data: T.nilable(String) + ).void + end + def initialize( + data: "" + ) + end + + # Opaque internal data. + sig { returns(String) } + def data + end + + # Opaque internal data. + sig { params(value: String).void } + def data=(value) + end + + # Opaque internal data. + sig { void } + def clear_data + 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::Callback::Internal) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Callback::Internal).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Callback::Internal) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Callback::Internal, 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::Common::V1::Link::WorkflowEvent + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String), + event_ref: T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent::EventReference), + request_id_ref: T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent::RequestIdReference) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "", + event_ref: nil, + request_id_ref: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent::EventReference)) } + def event_ref + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent::EventReference)).void } + def event_ref=(value) + end + + sig { void } + def clear_event_ref + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent::RequestIdReference)) } + def request_id_ref + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link::WorkflowEvent::RequestIdReference)).void } + def request_id_ref=(value) + end + + sig { void } + def clear_request_id_ref + end + + sig { returns(T.nilable(Symbol)) } + def reference + 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::Link::WorkflowEvent) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::WorkflowEvent).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Link::WorkflowEvent) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::WorkflowEvent, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A link to a built-in batch job. +# Batch jobs can be used to perform operations on a set of workflows (e.g. terminate, signal, cancel, etc). +# This link can be put on workflow history events generated by actions taken by a batch job. +class Temporalio::Api::Common::V1::Link::BatchJob + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + job_id: T.nilable(String) + ).void + end + def initialize( + job_id: "" + ) + end + + sig { returns(String) } + def job_id + end + + sig { params(value: String).void } + def job_id=(value) + end + + sig { void } + def clear_job_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Common::V1::Link::BatchJob) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::BatchJob).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Link::BatchJob) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::BatchJob, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A link to an activity. +class Temporalio::Api::Common::V1::Link::Activity + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + activity_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + activity_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Common::V1::Link::Activity) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::Activity).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Link::Activity) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::Activity, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A link to a standalone Nexus operation. +class Temporalio::Api::Common::V1::Link::NexusOperation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + operation_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + operation_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def operation_id + end + + sig { params(value: String).void } + def operation_id=(value) + end + + sig { void } + def clear_operation_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Common::V1::Link::NexusOperation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::NexusOperation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Link::NexusOperation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::NexusOperation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# EventReference is a direct reference to a history event through the event ID. +class Temporalio::Api::Common::V1::Link::WorkflowEvent::EventReference + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + event_id: T.nilable(Integer), + event_type: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + event_id: 0, + event_type: :EVENT_TYPE_UNSPECIFIED + ) + end + + sig { returns(Integer) } + def event_id + end + + sig { params(value: Integer).void } + def event_id=(value) + end + + sig { void } + def clear_event_id + end + + sig { returns(T.any(Symbol, Integer)) } + def event_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def event_type=(value) + end + + sig { void } + def clear_event_type + 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::Link::WorkflowEvent::EventReference) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::WorkflowEvent::EventReference).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Link::WorkflowEvent::EventReference) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::WorkflowEvent::EventReference, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# RequestIdReference is a indirect reference to a history event through the request ID. +class Temporalio::Api::Common::V1::Link::WorkflowEvent::RequestIdReference + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + request_id: T.nilable(String), + event_type: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + request_id: "", + event_type: :EVENT_TYPE_UNSPECIFIED + ) + end + + sig { returns(String) } + def request_id + end + + sig { params(value: String).void } + def request_id=(value) + end + + sig { void } + def clear_request_id + end + + sig { returns(T.any(Symbol, Integer)) } + def event_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def event_type=(value) + end + + sig { void } + def clear_event_type + 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::Link::WorkflowEvent::RequestIdReference) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::WorkflowEvent::RequestIdReference).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Common::V1::Link::WorkflowEvent::RequestIdReference) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Common::V1::Link::WorkflowEvent::RequestIdReference, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/compute/v1/config.rbi b/temporalio/rbi/temporalio/api/compute/v1/config.rbi new file mode 100644 index 00000000..7546c6ff --- /dev/null +++ b/temporalio/rbi/temporalio/api/compute/v1/config.rbi @@ -0,0 +1,421 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/compute/v1/config.proto +# typed: strict + +class Temporalio::Api::Compute::V1::ComputeConfigScalingGroup + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_queue_types: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + provider: T.nilable(Temporalio::Api::Compute::V1::ComputeProvider), + scaler: T.nilable(Temporalio::Api::Compute::V1::ComputeScaler) + ).void + end + def initialize( + task_queue_types: [], + provider: nil, + scaler: nil + ) + end + + # Optional. The set of task queue types this scaling group serves. +# If not provided, this scaling group serves all not otherwise defined +# task types. + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def task_queue_types + end + + # Optional. The set of task queue types this scaling group serves. +# If not provided, this scaling group serves all not otherwise defined +# task types. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def task_queue_types=(value) + end + + # Optional. The set of task queue types this scaling group serves. +# If not provided, this scaling group serves all not otherwise defined +# task types. + sig { void } + def clear_task_queue_types + end + + # Stores instructions for a worker control plane controller how to respond +# to worker lifeycle events. + sig { returns(T.nilable(Temporalio::Api::Compute::V1::ComputeProvider)) } + def provider + end + + # Stores instructions for a worker control plane controller how to respond +# to worker lifeycle events. + sig { params(value: T.nilable(Temporalio::Api::Compute::V1::ComputeProvider)).void } + def provider=(value) + end + + # Stores instructions for a worker control plane controller how to respond +# to worker lifeycle events. + sig { void } + def clear_provider + end + + # Informs a worker lifecycle controller *when* and *how often* to perform +# certain worker lifecycle actions like starting a serverless worker. + sig { returns(T.nilable(Temporalio::Api::Compute::V1::ComputeScaler)) } + def scaler + end + + # Informs a worker lifecycle controller *when* and *how often* to perform +# certain worker lifecycle actions like starting a serverless worker. + sig { params(value: T.nilable(Temporalio::Api::Compute::V1::ComputeScaler)).void } + def scaler=(value) + end + + # Informs a worker lifecycle controller *when* and *how often* to perform +# certain worker lifecycle actions like starting a serverless worker. + sig { void } + def clear_scaler + 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::Compute::V1::ComputeConfigScalingGroup) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfigScalingGroup).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Compute::V1::ComputeConfigScalingGroup) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfigScalingGroup, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# ComputeConfig stores configuration that helps a worker control plane +# controller understand *when* and *how* to respond to worker lifecycle +# events. +class Temporalio::Api::Compute::V1::ComputeConfig + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scaling_groups: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroup)]) + ).void + end + def initialize( + scaling_groups: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Compute::V1::ComputeConfigScalingGroup) + ) + end + + # Each scaling group describes a compute config for a specific subset of the worker +# deployment version: covering a specific set of task types and/or regions. +# Having different configurations for different task types, allows independent +# tuning of activity and workflow task processing (for example). +# +# The key of the map is the ID of the scaling group used to reference it in subsequent +# update calls. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroup)]) } + def scaling_groups + end + + # Each scaling group describes a compute config for a specific subset of the worker +# deployment version: covering a specific set of task types and/or regions. +# Having different configurations for different task types, allows independent +# tuning of activity and workflow task processing (for example). +# +# The key of the map is the ID of the scaling group used to reference it in subsequent +# update calls. + sig { params(value: ::Google::Protobuf::Map).void } + def scaling_groups=(value) + end + + # Each scaling group describes a compute config for a specific subset of the worker +# deployment version: covering a specific set of task types and/or regions. +# Having different configurations for different task types, allows independent +# tuning of activity and workflow task processing (for example). +# +# The key of the map is the ID of the scaling group used to reference it in subsequent +# update calls. + sig { void } + def clear_scaling_groups + 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::Compute::V1::ComputeConfig) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfig).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Compute::V1::ComputeConfig) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfig, 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::Compute::V1::ComputeConfigScalingGroupUpdate + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scaling_group: T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroup), + update_mask: T.nilable(Google::Protobuf::FieldMask) + ).void + end + def initialize( + scaling_group: nil, + update_mask: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroup)) } + def scaling_group + end + + sig { params(value: T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroup)).void } + def scaling_group=(value) + end + + sig { void } + def clear_scaling_group + end + + # Controls which fields from `scaling_group` will be applied. Semantics: +# - Mask is ignored for new scaling groups (only applicable when scaling group already exists). +# - Empty mask for an existing scaling group is no-op: no change. +# - Non-empty mask for an existing scaling group will update/unset only to the fields +# mentioned in the mask. +# - Accepted paths: "task_queue_types", "provider", "provider.type", "provider.details", +# "provider.nexus_endpoint", "scaler", "scaler.type", "scaler.details" + sig { returns(T.nilable(Google::Protobuf::FieldMask)) } + def update_mask + end + + # Controls which fields from `scaling_group` will be applied. Semantics: +# - Mask is ignored for new scaling groups (only applicable when scaling group already exists). +# - Empty mask for an existing scaling group is no-op: no change. +# - Non-empty mask for an existing scaling group will update/unset only to the fields +# mentioned in the mask. +# - Accepted paths: "task_queue_types", "provider", "provider.type", "provider.details", +# "provider.nexus_endpoint", "scaler", "scaler.type", "scaler.details" + sig { params(value: T.nilable(Google::Protobuf::FieldMask)).void } + def update_mask=(value) + end + + # Controls which fields from `scaling_group` will be applied. Semantics: +# - Mask is ignored for new scaling groups (only applicable when scaling group already exists). +# - Empty mask for an existing scaling group is no-op: no change. +# - Non-empty mask for an existing scaling group will update/unset only to the fields +# mentioned in the mask. +# - Accepted paths: "task_queue_types", "provider", "provider.type", "provider.details", +# "provider.nexus_endpoint", "scaler", "scaler.type", "scaler.details" + sig { void } + def clear_update_mask + 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::Compute::V1::ComputeConfigScalingGroupUpdate) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A subset of information in ComputeConfig optimized for list views. +class Temporalio::Api::Compute::V1::ComputeConfigSummary + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scaling_groups: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroupSummary)]) + ).void + end + def initialize( + scaling_groups: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Compute::V1::ComputeConfigScalingGroupSummary) + ) + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroupSummary)]) } + def scaling_groups + end + + sig { params(value: ::Google::Protobuf::Map).void } + def scaling_groups=(value) + end + + sig { void } + def clear_scaling_groups + 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::Compute::V1::ComputeConfigSummary) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfigSummary).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Compute::V1::ComputeConfigSummary) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfigSummary, 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::Compute::V1::ComputeConfigScalingGroupSummary + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_queue_types: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + provider_type: T.nilable(String) + ).void + end + def initialize( + task_queue_types: [], + provider_type: "" + ) + end + + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def task_queue_types + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def task_queue_types=(value) + end + + sig { void } + def clear_task_queue_types + end + + sig { returns(String) } + def provider_type + end + + sig { params(value: String).void } + def provider_type=(value) + end + + sig { void } + def clear_provider_type + 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::Compute::V1::ComputeConfigScalingGroupSummary) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfigScalingGroupSummary).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Compute::V1::ComputeConfigScalingGroupSummary) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeConfigScalingGroupSummary, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/compute/v1/provider.rbi b/temporalio/rbi/temporalio/api/compute/v1/provider.rbi new file mode 100644 index 00000000..37d59d0b --- /dev/null +++ b/temporalio/rbi/temporalio/api/compute/v1/provider.rbi @@ -0,0 +1,125 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/compute/v1/provider.proto +# typed: strict + +# ComputeProvider stores information used by a worker control plane controller +# to respond to worker lifecycle events. For example, when a Task is received +# on a TaskQueue that has no active pollers, a serverless worker lifecycle +# controller might need to invoke an AWS Lambda Function that itself ends up +# calling the SDK's worker.New() function. +class Temporalio::Api::Compute::V1::ComputeProvider + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(String), + details: T.nilable(Temporalio::Api::Common::V1::Payload), + nexus_endpoint: T.nilable(String) + ).void + end + def initialize( + type: "", + details: nil, + nexus_endpoint: "" + ) + end + + # Type of the compute provider. This string is implementation-specific and +# can be used by implementations to understand how to interpret the +# contents of the provider_details field. + sig { returns(String) } + def type + end + + # Type of the compute provider. This string is implementation-specific and +# can be used by implementations to understand how to interpret the +# contents of the provider_details field. + sig { params(value: String).void } + def type=(value) + end + + # Type of the compute provider. This string is implementation-specific and +# can be used by implementations to understand how to interpret the +# contents of the provider_details field. + sig { void } + def clear_type + end + + # Contains provider-specific instructions and configuration. +# For server-implemented providers, use the SDK's default content +# converter to ensure the server can understand it. +# For remote-implemented providers, you might use your own content +# converters according to what the remote endpoints understand. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def details + end + + # Contains provider-specific instructions and configuration. +# For server-implemented providers, use the SDK's default content +# converter to ensure the server can understand it. +# For remote-implemented providers, you might use your own content +# converters according to what the remote endpoints understand. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def details=(value) + end + + # Contains provider-specific instructions and configuration. +# For server-implemented providers, use the SDK's default content +# converter to ensure the server can understand it. +# For remote-implemented providers, you might use your own content +# converters according to what the remote endpoints understand. + sig { void } + def clear_details + end + + # Optional. If the compute provider is a Nexus service, this should point +# there. + sig { returns(String) } + def nexus_endpoint + end + + # Optional. If the compute provider is a Nexus service, this should point +# there. + sig { params(value: String).void } + def nexus_endpoint=(value) + end + + # Optional. If the compute provider is a Nexus service, this should point +# there. + sig { void } + def clear_nexus_endpoint + 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::Compute::V1::ComputeProvider) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeProvider).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Compute::V1::ComputeProvider) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeProvider, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/compute/v1/scaler.rbi b/temporalio/rbi/temporalio/api/compute/v1/scaler.rbi new file mode 100644 index 00000000..cfd37f51 --- /dev/null +++ b/temporalio/rbi/temporalio/api/compute/v1/scaler.rbi @@ -0,0 +1,102 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/compute/v1/scaler.proto +# typed: strict + +# ComputeScaler instructs the Temporal Service when to scale up or down the number of +# Workers that comprise a WorkerDeployment. +class Temporalio::Api::Compute::V1::ComputeScaler + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(String), + details: T.nilable(Temporalio::Api::Common::V1::Payload) + ).void + end + def initialize( + type: "", + details: nil + ) + end + + # Type of the compute scaler. this string is implementation-specific and +# can be used by implementations to understand how to interpret the +# contents of the scaler_details field. + sig { returns(String) } + def type + end + + # Type of the compute scaler. this string is implementation-specific and +# can be used by implementations to understand how to interpret the +# contents of the scaler_details field. + sig { params(value: String).void } + def type=(value) + end + + # Type of the compute scaler. this string is implementation-specific and +# can be used by implementations to understand how to interpret the +# contents of the scaler_details field. + sig { void } + def clear_type + end + + # Contains scaler-specific instructions and configuration. +# For server-implemented scalers, use the SDK's default data +# converter to ensure the server can understand it. +# For remote-implemented scalers, you might use your own data +# converters according to what the remote endpoints understand. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def details + end + + # Contains scaler-specific instructions and configuration. +# For server-implemented scalers, use the SDK's default data +# converter to ensure the server can understand it. +# For remote-implemented scalers, you might use your own data +# converters according to what the remote endpoints understand. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def details=(value) + end + + # Contains scaler-specific instructions and configuration. +# For server-implemented scalers, use the SDK's default data +# converter to ensure the server can understand it. +# For remote-implemented scalers, you might use your own data +# converters according to what the remote endpoints understand. + sig { void } + def clear_details + 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::Compute::V1::ComputeScaler) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeScaler).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Compute::V1::ComputeScaler) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Compute::V1::ComputeScaler, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/deployment/v1/message.rbi b/temporalio/rbi/temporalio/api/deployment/v1/message.rbi new file mode 100644 index 00000000..887b5999 --- /dev/null +++ b/temporalio/rbi/temporalio/api/deployment/v1/message.rbi @@ -0,0 +1,2176 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/deployment/v1/message.proto +# typed: strict + +# Worker Deployment options set in SDK that need to be sent to server in every poll. +class Temporalio::Api::Deployment::V1::WorkerDeploymentOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deployment_name: T.nilable(String), + build_id: T.nilable(String), + worker_versioning_mode: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + deployment_name: "", + build_id: "", + worker_versioning_mode: :WORKER_VERSIONING_MODE_UNSPECIFIED + ) + end + + # Required when `worker_versioning_mode==VERSIONED`. + sig { returns(String) } + def deployment_name + end + + # Required when `worker_versioning_mode==VERSIONED`. + sig { params(value: String).void } + def deployment_name=(value) + end + + # Required when `worker_versioning_mode==VERSIONED`. + sig { void } + def clear_deployment_name + end + + # The Build ID of the worker. Required when `worker_versioning_mode==VERSIONED`, in which case, +# the worker will be part of a Deployment Version. + sig { returns(String) } + def build_id + end + + # The Build ID of the worker. Required when `worker_versioning_mode==VERSIONED`, in which case, +# the worker will be part of a Deployment Version. + sig { params(value: String).void } + def build_id=(value) + end + + # The Build ID of the worker. Required when `worker_versioning_mode==VERSIONED`, in which case, +# the worker will be part of a Deployment Version. + sig { void } + def clear_build_id + end + + # Required. Versioning Mode for this worker. Must be the same for all workers with the +# same `deployment_name` and `build_id` combination, across all Task Queues. +# When `worker_versioning_mode==VERSIONED`, the worker will be part of a Deployment Version. + sig { returns(T.any(Symbol, Integer)) } + def worker_versioning_mode + end + + # Required. Versioning Mode for this worker. Must be the same for all workers with the +# same `deployment_name` and `build_id` combination, across all Task Queues. +# When `worker_versioning_mode==VERSIONED`, the worker will be part of a Deployment Version. + sig { params(value: T.any(Symbol, String, Integer)).void } + def worker_versioning_mode=(value) + end + + # Required. Versioning Mode for this worker. Must be the same for all workers with the +# same `deployment_name` and `build_id` combination, across all Task Queues. +# When `worker_versioning_mode==VERSIONED`, the worker will be part of a Deployment Version. + sig { void } + def clear_worker_versioning_mode + 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::Deployment::V1::WorkerDeploymentOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Deployment` identifies a deployment of Temporal workers. The combination of deployment series +# name + build ID serves as the identifier. User can use `WorkerDeploymentOptions` in their worker +# programs to specify these values. +# Deprecated. +class Temporalio::Api::Deployment::V1::Deployment + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + series_name: T.nilable(String), + build_id: T.nilable(String) + ).void + end + def initialize( + series_name: "", + build_id: "" + ) + end + + # Different versions of the same worker service/application are related together by having a +# shared series name. +# Out of all deployments of a series, one can be designated as the current deployment, which +# receives new workflow executions and new tasks of workflows with +# `VERSIONING_BEHAVIOR_AUTO_UPGRADE` versioning behavior. + sig { returns(String) } + def series_name + end + + # Different versions of the same worker service/application are related together by having a +# shared series name. +# Out of all deployments of a series, one can be designated as the current deployment, which +# receives new workflow executions and new tasks of workflows with +# `VERSIONING_BEHAVIOR_AUTO_UPGRADE` versioning behavior. + sig { params(value: String).void } + def series_name=(value) + end + + # Different versions of the same worker service/application are related together by having a +# shared series name. +# Out of all deployments of a series, one can be designated as the current deployment, which +# receives new workflow executions and new tasks of workflows with +# `VERSIONING_BEHAVIOR_AUTO_UPGRADE` versioning behavior. + sig { void } + def clear_series_name + end + + # Build ID changes with each version of the worker when the worker program code and/or config +# changes. + sig { returns(String) } + def build_id + end + + # Build ID changes with each version of the worker when the worker program code and/or config +# changes. + sig { params(value: String).void } + def build_id=(value) + end + + # Build ID changes with each version of the worker when the worker program code and/or config +# changes. + sig { void } + def clear_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::Deployment::V1::Deployment) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::Deployment).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::Deployment) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::Deployment, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `DeploymentInfo` holds information about a deployment. Deployment information is tracked +# automatically by server as soon as the first poll from that deployment reaches the server. There +# can be multiple task queue workers in a single deployment which are listed in this message. +# Deprecated. +class Temporalio::Api::Deployment::V1::DeploymentInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + create_time: T.nilable(Google::Protobuf::Timestamp), + task_queue_infos: T.nilable(T::Array[T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo::TaskQueueInfo)]), + metadata: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + is_current: T.nilable(T::Boolean) + ).void + end + def initialize( + deployment: nil, + create_time: nil, + task_queue_infos: [], + metadata: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + is_current: false + ) + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + sig { void } + def clear_deployment + 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 { returns(T::Array[T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo::TaskQueueInfo)]) } + def task_queue_infos + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def task_queue_infos=(value) + end + + sig { void } + def clear_task_queue_infos + end + + # A user-defined set of key-values. Can be updated as part of write operations to the +# deployment, such as `SetCurrentDeployment`. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def metadata + end + + # A user-defined set of key-values. Can be updated as part of write operations to the +# deployment, such as `SetCurrentDeployment`. + sig { params(value: ::Google::Protobuf::Map).void } + def metadata=(value) + end + + # A user-defined set of key-values. Can be updated as part of write operations to the +# deployment, such as `SetCurrentDeployment`. + sig { void } + def clear_metadata + end + + # If this deployment is the current deployment of its deployment series. + sig { returns(T::Boolean) } + def is_current + end + + # If this deployment is the current deployment of its deployment series. + sig { params(value: T::Boolean).void } + def is_current=(value) + end + + # If this deployment is the current deployment of its deployment series. + sig { void } + def clear_is_current + 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::Deployment::V1::DeploymentInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::DeploymentInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::DeploymentInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::DeploymentInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used as part of Deployment write APIs to update metadata attached to a deployment. +# Deprecated. +class Temporalio::Api::Deployment::V1::UpdateDeploymentMetadata + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + upsert_entries: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + remove_entries: T.nilable(T::Array[String]) + ).void + end + def initialize( + upsert_entries: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + remove_entries: [] + ) + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def upsert_entries + end + + sig { params(value: ::Google::Protobuf::Map).void } + def upsert_entries=(value) + end + + sig { void } + def clear_upsert_entries + end + + # List of keys to remove from the metadata. + sig { returns(T::Array[String]) } + def remove_entries + end + + # List of keys to remove from the metadata. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def remove_entries=(value) + end + + # List of keys to remove from the metadata. + sig { void } + def clear_remove_entries + 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::Deployment::V1::UpdateDeploymentMetadata) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::UpdateDeploymentMetadata).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::UpdateDeploymentMetadata) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::UpdateDeploymentMetadata, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# DeploymentListInfo is an abbreviated set of fields from DeploymentInfo that's returned in +# ListDeployments. +# Deprecated. +class Temporalio::Api::Deployment::V1::DeploymentListInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + create_time: T.nilable(Google::Protobuf::Timestamp), + is_current: T.nilable(T::Boolean) + ).void + end + def initialize( + deployment: nil, + create_time: nil, + is_current: false + ) + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + sig { void } + def clear_deployment + 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 + + # If this deployment is the current deployment of its deployment series. + sig { returns(T::Boolean) } + def is_current + end + + # If this deployment is the current deployment of its deployment series. + sig { params(value: T::Boolean).void } + def is_current=(value) + end + + # If this deployment is the current deployment of its deployment series. + sig { void } + def clear_is_current + 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::Deployment::V1::DeploymentListInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::DeploymentListInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::DeploymentListInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::DeploymentListInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A Worker Deployment Version (Version, for short) represents all workers of the same +# code and config within a Deployment. Workers of the same Version are expected to +# behave exactly the same so when executions move between them there are no +# non-determinism issues. +# Worker Deployment Versions are created in Temporal server automatically when +# their first poller arrives to the server. +class Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + version: T.nilable(String), + status: T.nilable(T.any(Symbol, String, Integer)), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + deployment_name: T.nilable(String), + create_time: T.nilable(Google::Protobuf::Timestamp), + routing_changed_time: T.nilable(Google::Protobuf::Timestamp), + current_since_time: T.nilable(Google::Protobuf::Timestamp), + ramping_since_time: T.nilable(Google::Protobuf::Timestamp), + first_activation_time: T.nilable(Google::Protobuf::Timestamp), + last_current_time: T.nilable(Google::Protobuf::Timestamp), + last_deactivation_time: T.nilable(Google::Protobuf::Timestamp), + ramp_percentage: T.nilable(Float), + task_queue_infos: T.nilable(T::Array[T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo::VersionTaskQueueInfo)]), + drainage_info: T.nilable(Temporalio::Api::Deployment::V1::VersionDrainageInfo), + metadata: T.nilable(Temporalio::Api::Deployment::V1::VersionMetadata), + compute_config: T.nilable(Temporalio::Api::Compute::V1::ComputeConfig), + last_modifier_identity: T.nilable(String) + ).void + end + def initialize( + version: "", + status: :WORKER_DEPLOYMENT_VERSION_STATUS_UNSPECIFIED, + deployment_version: nil, + deployment_name: "", + create_time: nil, + routing_changed_time: nil, + current_since_time: nil, + ramping_since_time: nil, + first_activation_time: nil, + last_current_time: nil, + last_deactivation_time: nil, + ramp_percentage: 0.0, + task_queue_infos: [], + drainage_info: nil, + metadata: nil, + compute_config: nil, + last_modifier_identity: "" + ) + end + + # Deprecated. Use `deployment_version`. + sig { returns(String) } + def version + end + + # Deprecated. Use `deployment_version`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `deployment_version`. + sig { void } + def clear_version + end + + # The status of the Worker Deployment Version. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # The status of the Worker Deployment Version. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # The status of the Worker Deployment Version. + sig { void } + def clear_status + end + + # Required. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # Required. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # Required. + sig { void } + def clear_deployment_version + end + + # Deprecated. User deployment_version.deployment_name. + sig { returns(String) } + def deployment_name + end + + # Deprecated. User deployment_version.deployment_name. + sig { params(value: String).void } + def deployment_name=(value) + end + + # Deprecated. User deployment_version.deployment_name. + sig { void } + def clear_deployment_name + 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 + + # Last time `current_since_time`, `ramping_since_time, or `ramp_percentage` of this version changed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def routing_changed_time + end + + # Last time `current_since_time`, `ramping_since_time, or `ramp_percentage` of this version changed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def routing_changed_time=(value) + end + + # Last time `current_since_time`, `ramping_since_time, or `ramp_percentage` of this version changed. + sig { void } + def clear_routing_changed_time + end + + # (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) +# Unset if not current. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def current_since_time + end + + # (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) +# Unset if not current. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def current_since_time=(value) + end + + # (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) +# Unset if not current. + sig { void } + def clear_current_since_time + end + + # (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) +# Unset if not ramping. Updated when the version first starts ramping, not on each ramp change. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def ramping_since_time + end + + # (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) +# Unset if not ramping. Updated when the version first starts ramping, not on each ramp change. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def ramping_since_time=(value) + end + + # (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) +# Unset if not ramping. Updated when the version first starts ramping, not on each ramp change. + sig { void } + def clear_ramping_since_time + end + + # Timestamp when this version first became current or ramping. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def first_activation_time + end + + # Timestamp when this version first became current or ramping. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def first_activation_time=(value) + end + + # Timestamp when this version first became current or ramping. + sig { void } + def clear_first_activation_time + end + + # Timestamp when this version last became current. +# Can be used to determine whether a version has ever been Current. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_current_time + end + + # Timestamp when this version last became current. +# Can be used to determine whether a version has ever been Current. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_current_time=(value) + end + + # Timestamp when this version last became current. +# Can be used to determine whether a version has ever been Current. + sig { void } + def clear_last_current_time + end + + # Timestamp when this version last stopped being current or ramping. +# Cleared if the version becomes current or ramping again. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_deactivation_time + end + + # Timestamp when this version last stopped being current or ramping. +# Cleared if the version becomes current or ramping again. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_deactivation_time=(value) + end + + # Timestamp when this version last stopped being current or ramping. +# Cleared if the version becomes current or ramping again. + sig { void } + def clear_last_deactivation_time + end + + # Range: [0, 100]. Must be zero if the version is not ramping (i.e. `ramping_since_time` is nil). +# Can be in the range [0, 100] if the version is ramping. + sig { returns(Float) } + def ramp_percentage + end + + # Range: [0, 100]. Must be zero if the version is not ramping (i.e. `ramping_since_time` is nil). +# Can be in the range [0, 100] if the version is ramping. + sig { params(value: Float).void } + def ramp_percentage=(value) + end + + # Range: [0, 100]. Must be zero if the version is not ramping (i.e. `ramping_since_time` is nil). +# Can be in the range [0, 100] if the version is ramping. + sig { void } + def clear_ramp_percentage + end + + # All the Task Queues that have ever polled from this Deployment version. +# Deprecated. Use `version_task_queues` in DescribeWorkerDeploymentVersionResponse instead. + sig { returns(T::Array[T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo::VersionTaskQueueInfo)]) } + def task_queue_infos + end + + # All the Task Queues that have ever polled from this Deployment version. +# Deprecated. Use `version_task_queues` in DescribeWorkerDeploymentVersionResponse instead. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def task_queue_infos=(value) + end + + # All the Task Queues that have ever polled from this Deployment version. +# Deprecated. Use `version_task_queues` in DescribeWorkerDeploymentVersionResponse instead. + sig { void } + def clear_task_queue_infos + end + + # Helps user determine when it is safe to decommission the workers of this +# Version. Not present when version is current or ramping. +# Current limitations: +# - Not supported for Unversioned mode. +# - Periodically refreshed, may have delays up to few minutes (consult the +# last_checked_time value). +# - Refreshed only when version is not current or ramping AND the status is not +# "drained" yet. +# - Once the status is changed to "drained", it is not changed until the Version +# becomes Current or Ramping again, at which time the drainage info is cleared. +# This means if the Version is "drained" but new workflows are sent to it via +# Pinned Versioning Override, the status does not account for those Pinned-override +# executions and remains "drained". + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::VersionDrainageInfo)) } + def drainage_info + end + + # Helps user determine when it is safe to decommission the workers of this +# Version. Not present when version is current or ramping. +# Current limitations: +# - Not supported for Unversioned mode. +# - Periodically refreshed, may have delays up to few minutes (consult the +# last_checked_time value). +# - Refreshed only when version is not current or ramping AND the status is not +# "drained" yet. +# - Once the status is changed to "drained", it is not changed until the Version +# becomes Current or Ramping again, at which time the drainage info is cleared. +# This means if the Version is "drained" but new workflows are sent to it via +# Pinned Versioning Override, the status does not account for those Pinned-override +# executions and remains "drained". + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::VersionDrainageInfo)).void } + def drainage_info=(value) + end + + # Helps user determine when it is safe to decommission the workers of this +# Version. Not present when version is current or ramping. +# Current limitations: +# - Not supported for Unversioned mode. +# - Periodically refreshed, may have delays up to few minutes (consult the +# last_checked_time value). +# - Refreshed only when version is not current or ramping AND the status is not +# "drained" yet. +# - Once the status is changed to "drained", it is not changed until the Version +# becomes Current or Ramping again, at which time the drainage info is cleared. +# This means if the Version is "drained" but new workflows are sent to it via +# Pinned Versioning Override, the status does not account for those Pinned-override +# executions and remains "drained". + sig { void } + def clear_drainage_info + end + + # Arbitrary user-provided metadata attached to this version. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::VersionMetadata)) } + def metadata + end + + # Arbitrary user-provided metadata attached to this version. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::VersionMetadata)).void } + def metadata=(value) + end + + # Arbitrary user-provided metadata attached to this version. + sig { void } + def clear_metadata + end + + # Optional. Contains the new worker compute configuration for the Worker +# Deployment. Used for worker scale management. + sig { returns(T.nilable(Temporalio::Api::Compute::V1::ComputeConfig)) } + def compute_config + end + + # Optional. Contains the new worker compute configuration for the Worker +# Deployment. Used for worker scale management. + sig { params(value: T.nilable(Temporalio::Api::Compute::V1::ComputeConfig)).void } + def compute_config=(value) + end + + # Optional. Contains the new worker compute configuration for the Worker +# Deployment. Used for worker scale management. + sig { void } + def clear_compute_config + end + + # Identity of the last client who modified the configuration of this Version. +# As of now, this field only covers changes through the following APIs: +# - `CreateWorkerDeploymentVersion` +# - `UpdateWorkerDeploymentVersionComputeConfig` +# - `UpdateWorkerDeploymentVersionMetadata` + sig { returns(String) } + def last_modifier_identity + end + + # Identity of the last client who modified the configuration of this Version. +# As of now, this field only covers changes through the following APIs: +# - `CreateWorkerDeploymentVersion` +# - `UpdateWorkerDeploymentVersionComputeConfig` +# - `UpdateWorkerDeploymentVersionMetadata` + sig { params(value: String).void } + def last_modifier_identity=(value) + end + + # Identity of the last client who modified the configuration of this Version. +# As of now, this field only covers changes through the following APIs: +# - `CreateWorkerDeploymentVersion` +# - `UpdateWorkerDeploymentVersionComputeConfig` +# - `UpdateWorkerDeploymentVersionMetadata` + sig { void } + def clear_last_modifier_identity + 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::Deployment::V1::WorkerDeploymentVersionInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Information about workflow drainage to help the user determine when it is safe +# to decommission a Version. Not present while version is current or ramping. +class Temporalio::Api::Deployment::V1::VersionDrainageInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + status: T.nilable(T.any(Symbol, String, Integer)), + last_changed_time: T.nilable(Google::Protobuf::Timestamp), + last_checked_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + status: :VERSION_DRAINAGE_STATUS_UNSPECIFIED, + last_changed_time: nil, + last_checked_time: nil + ) + end + + # Set to DRAINING when the version first stops accepting new executions (is no longer current or ramping). +# Set to DRAINED when no more open pinned workflows exist on this version. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # Set to DRAINING when the version first stops accepting new executions (is no longer current or ramping). +# Set to DRAINED when no more open pinned workflows exist on this version. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # Set to DRAINING when the version first stops accepting new executions (is no longer current or ramping). +# Set to DRAINED when no more open pinned workflows exist on this version. + sig { void } + def clear_status + end + + # Last time the drainage status changed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_changed_time + end + + # Last time the drainage status changed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_changed_time=(value) + end + + # Last time the drainage status changed. + sig { void } + def clear_last_changed_time + end + + # Last time the system checked for drainage of this version. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_checked_time + end + + # Last time the system checked for drainage of this version. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_checked_time=(value) + end + + # Last time the system checked for drainage of this version. + sig { void } + def clear_last_checked_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::Deployment::V1::VersionDrainageInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::VersionDrainageInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::VersionDrainageInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::VersionDrainageInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A Worker Deployment (Deployment, for short) represents all workers serving +# a shared set of Task Queues. Typically, a Deployment represents one service or +# application. +# A Deployment contains multiple Deployment Versions, each representing a different +# version of workers. (see documentation of WorkerDeploymentVersionInfo) +# Deployment records are created in Temporal server automatically when their +# first poller arrives to the server. +class Temporalio::Api::Deployment::V1::WorkerDeploymentInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + version_summaries: T.nilable(T::Array[T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary)]), + create_time: T.nilable(Google::Protobuf::Timestamp), + routing_config: T.nilable(Temporalio::Api::Deployment::V1::RoutingConfig), + last_modifier_identity: T.nilable(String), + manager_identity: T.nilable(String), + routing_config_update_state: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + name: "", + version_summaries: [], + create_time: nil, + routing_config: nil, + last_modifier_identity: "", + manager_identity: "", + routing_config_update_state: :ROUTING_CONFIG_UPDATE_STATE_UNSPECIFIED + ) + end + + # Identifies a Worker Deployment. Must be unique within the namespace. + sig { returns(String) } + def name + end + + # Identifies a Worker Deployment. Must be unique within the namespace. + sig { params(value: String).void } + def name=(value) + end + + # Identifies a Worker Deployment. Must be unique within the namespace. + sig { void } + def clear_name + end + + # Deployment Versions that are currently tracked in this Deployment. A DeploymentVersion will be +# cleaned up automatically if all the following conditions meet: +# - It does not receive new executions (is not current or ramping) +# - It has no active pollers (see WorkerDeploymentVersionInfo.pollers_status) +# - It is drained (see WorkerDeploymentVersionInfo.drainage_status) + sig { returns(T::Array[T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary)]) } + def version_summaries + end + + # Deployment Versions that are currently tracked in this Deployment. A DeploymentVersion will be +# cleaned up automatically if all the following conditions meet: +# - It does not receive new executions (is not current or ramping) +# - It has no active pollers (see WorkerDeploymentVersionInfo.pollers_status) +# - It is drained (see WorkerDeploymentVersionInfo.drainage_status) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def version_summaries=(value) + end + + # Deployment Versions that are currently tracked in this Deployment. A DeploymentVersion will be +# cleaned up automatically if all the following conditions meet: +# - It does not receive new executions (is not current or ramping) +# - It has no active pollers (see WorkerDeploymentVersionInfo.pollers_status) +# - It is drained (see WorkerDeploymentVersionInfo.drainage_status) + sig { void } + def clear_version_summaries + 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 { returns(T.nilable(Temporalio::Api::Deployment::V1::RoutingConfig)) } + def routing_config + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::RoutingConfig)).void } + def routing_config=(value) + end + + sig { void } + def clear_routing_config + end + + # Identity of the last client who modified the configuration of this Deployment. Set to the +# `identity` value sent by APIs such as `SetWorkerDeploymentCurrentVersion` and +# `SetWorkerDeploymentRampingVersion`. + sig { returns(String) } + def last_modifier_identity + end + + # Identity of the last client who modified the configuration of this Deployment. Set to the +# `identity` value sent by APIs such as `SetWorkerDeploymentCurrentVersion` and +# `SetWorkerDeploymentRampingVersion`. + sig { params(value: String).void } + def last_modifier_identity=(value) + end + + # Identity of the last client who modified the configuration of this Deployment. Set to the +# `identity` value sent by APIs such as `SetWorkerDeploymentCurrentVersion` and +# `SetWorkerDeploymentRampingVersion`. + sig { void } + def clear_last_modifier_identity + end + + # Identity of the client that has the exclusive right to make changes to this Worker Deployment. +# Empty by default. +# If this is set, clients whose identity does not match `manager_identity` will not be able to make changes +# to this Worker Deployment. They can either set their own identity as the manager or unset the field to proceed. + sig { returns(String) } + def manager_identity + end + + # Identity of the client that has the exclusive right to make changes to this Worker Deployment. +# Empty by default. +# If this is set, clients whose identity does not match `manager_identity` will not be able to make changes +# to this Worker Deployment. They can either set their own identity as the manager or unset the field to proceed. + sig { params(value: String).void } + def manager_identity=(value) + end + + # Identity of the client that has the exclusive right to make changes to this Worker Deployment. +# Empty by default. +# If this is set, clients whose identity does not match `manager_identity` will not be able to make changes +# to this Worker Deployment. They can either set their own identity as the manager or unset the field to proceed. + sig { void } + def clear_manager_identity + end + + # Indicates whether the routing_config has been fully propagated to all +# relevant task queues and their partitions. + sig { returns(T.any(Symbol, Integer)) } + def routing_config_update_state + end + + # Indicates whether the routing_config has been fully propagated to all +# relevant task queues and their partitions. + sig { params(value: T.any(Symbol, String, Integer)).void } + def routing_config_update_state=(value) + end + + # Indicates whether the routing_config has been fully propagated to all +# relevant task queues and their partitions. + sig { void } + def clear_routing_config_update_state + 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::Deployment::V1::WorkerDeploymentInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A Worker Deployment Version (Version, for short) represents a +# version of workers within a Worker Deployment. (see documentation of WorkerDeploymentVersionInfo) +# Version records are created in Temporal server automatically when their +# first poller arrives to the server. +# Experimental. Worker Deployment Versions are experimental and might significantly change in the future. +class Temporalio::Api::Deployment::V1::WorkerDeploymentVersion + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + build_id: T.nilable(String), + deployment_name: T.nilable(String) + ).void + end + def initialize( + build_id: "", + deployment_name: "" + ) + end + + # A unique identifier for this Version within the Deployment it is a part of. +# Not necessarily unique within the namespace. +# The combination of `deployment_name` and `build_id` uniquely identifies this +# Version within the namespace, because Deployment names are unique within a namespace. + sig { returns(String) } + def build_id + end + + # A unique identifier for this Version within the Deployment it is a part of. +# Not necessarily unique within the namespace. +# The combination of `deployment_name` and `build_id` uniquely identifies this +# Version within the namespace, because Deployment names are unique within a namespace. + sig { params(value: String).void } + def build_id=(value) + end + + # A unique identifier for this Version within the Deployment it is a part of. +# Not necessarily unique within the namespace. +# The combination of `deployment_name` and `build_id` uniquely identifies this +# Version within the namespace, because Deployment names are unique within a namespace. + sig { void } + def clear_build_id + end + + # Identifies the Worker Deployment this Version is part of. + sig { returns(String) } + def deployment_name + end + + # Identifies the Worker Deployment this Version is part of. + sig { params(value: String).void } + def deployment_name=(value) + end + + # Identifies the Worker Deployment this Version is part of. + sig { void } + def clear_deployment_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::Deployment::V1::WorkerDeploymentVersion) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentVersion).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentVersion, 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::Deployment::V1::VersionMetadata + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + entries: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + entries: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload) + ) + end + + # Arbitrary key-values. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def entries + end + + # Arbitrary key-values. + sig { params(value: ::Google::Protobuf::Map).void } + def entries=(value) + end + + # Arbitrary key-values. + sig { void } + def clear_entries + 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::Deployment::V1::VersionMetadata) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::VersionMetadata).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::VersionMetadata) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::VersionMetadata, 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::Deployment::V1::RoutingConfig + 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), + current_version_changed_time: T.nilable(Google::Protobuf::Timestamp), + ramping_version_changed_time: T.nilable(Google::Protobuf::Timestamp), + ramping_version_percentage_changed_time: T.nilable(Google::Protobuf::Timestamp), + revision_number: T.nilable(Integer) + ).void + end + def initialize( + current_deployment_version: nil, + current_version: "", + ramping_deployment_version: nil, + ramping_version: "", + ramping_version_percentage: 0.0, + current_version_changed_time: nil, + ramping_version_changed_time: nil, + ramping_version_percentage_changed_time: nil, + revision_number: 0 + ) + end + + # Specifies which Deployment Version should receive new workflow executions and tasks of +# existing unversioned or AutoUpgrade workflows. +# Nil value means no Version in this Deployment (except Ramping Version, if present) receives traffic other than tasks of previously Pinned workflows. In absence of a Current Version, remaining traffic after any ramp (if set) goes to 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 means no Version in this Deployment (except Ramping Version, if present) receives traffic other than tasks of previously Pinned workflows. In absence of a Current Version, remaining traffic after any ramp (if set) goes to 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 means no Version in this Deployment (except Ramping Version, if present) receives traffic other than tasks of previously Pinned workflows. In absence of a Current Version, remaining traffic after any ramp (if set) goes to 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 current version was changed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def current_version_changed_time + end + + # Last time current version was changed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def current_version_changed_time=(value) + end + + # Last time current version was changed. + sig { void } + def clear_current_version_changed_time + end + + # Last time ramping version was changed. Not updated if only the ramp percentage changes. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def ramping_version_changed_time + end + + # Last time ramping version was changed. Not updated if only the ramp percentage changes. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def ramping_version_changed_time=(value) + end + + # Last time ramping version was changed. Not updated if only the ramp percentage changes. + sig { void } + def clear_ramping_version_changed_time + end + + # Last time ramping version percentage was changed. +# If ramping version is changed, this is also updated, even if the percentage stays the same. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def ramping_version_percentage_changed_time + end + + # Last time ramping version percentage was changed. +# If ramping version is changed, this is also updated, even if the percentage stays the same. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def ramping_version_percentage_changed_time=(value) + end + + # Last time ramping version percentage was changed. +# If ramping version is changed, this is also updated, even if the percentage stays the same. + sig { void } + def clear_ramping_version_percentage_changed_time + end + + # Monotonically increasing value which is incremented on every mutation +# to any field of this message to achieve eventual consistency between task queues and their partitions. + sig { returns(Integer) } + def revision_number + end + + # Monotonically increasing value which is incremented on every mutation +# to any field of this message to achieve eventual consistency between task queues and their partitions. + sig { params(value: Integer).void } + def revision_number=(value) + end + + # Monotonically increasing value which is incremented on every mutation +# to any field of this message to achieve eventual consistency between task queues and their partitions. + sig { void } + def clear_revision_number + 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::Deployment::V1::RoutingConfig) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::RoutingConfig).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::RoutingConfig) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::RoutingConfig, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used as part of WorkflowExecutionStartedEventAttributes to pass down the AutoUpgrade behavior and source deployment version +# to a workflow execution whose parent/previous workflow has an AutoUpgrade behavior. +# Also used for Upgrade-on-CaN behaviors AutoUpgrade and UseRampingVersion. +class Temporalio::Api::Deployment::V1::InheritedAutoUpgradeInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + source_deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + source_deployment_revision_number: T.nilable(Integer), + continue_as_new_initial_versioning_behavior: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + source_deployment_version: nil, + source_deployment_revision_number: 0, + continue_as_new_initial_versioning_behavior: :CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_UNSPECIFIED + ) + end + + # The source deployment version of the parent/previous workflow. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def source_deployment_version + end + + # The source deployment version of the parent/previous workflow. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def source_deployment_version=(value) + end + + # The source deployment version of the parent/previous workflow. + sig { void } + def clear_source_deployment_version + end + + # The revision number of the source deployment version of the parent/previous workflow. + sig { returns(Integer) } + def source_deployment_revision_number + end + + # The revision number of the source deployment version of the parent/previous workflow. + sig { params(value: Integer).void } + def source_deployment_revision_number=(value) + end + + # The revision number of the source deployment version of the parent/previous workflow. + sig { void } + def clear_source_deployment_revision_number + end + + # Experimental. +# If this workflow is the result of a continue-as-new, this field is set to the initial_versioning_behavior +# specified in that command. +# Only used for the initial task of this run and the initial task of any retries of this run. +# Not passed to children or to future continue-as-new. +# +# Note: In the first release of Upgrade-on-CaN, when the only ContinueAsNewVersioningBehavior was AutoUpgrade, +# a non-empty InheritedAutoUpgradeInfo meant that the workflow should start as AutoUpgrade. So for compatibility +# with history events generated during that time, know that an UNSPECIFIED value here is equivalent to AutoUpgrade +# value if the InheritedAutoUpgradeInfo is non-empty. + sig { returns(T.any(Symbol, Integer)) } + def continue_as_new_initial_versioning_behavior + end + + # Experimental. +# If this workflow is the result of a continue-as-new, this field is set to the initial_versioning_behavior +# specified in that command. +# Only used for the initial task of this run and the initial task of any retries of this run. +# Not passed to children or to future continue-as-new. +# +# Note: In the first release of Upgrade-on-CaN, when the only ContinueAsNewVersioningBehavior was AutoUpgrade, +# a non-empty InheritedAutoUpgradeInfo meant that the workflow should start as AutoUpgrade. So for compatibility +# with history events generated during that time, know that an UNSPECIFIED value here is equivalent to AutoUpgrade +# value if the InheritedAutoUpgradeInfo is non-empty. + sig { params(value: T.any(Symbol, String, Integer)).void } + def continue_as_new_initial_versioning_behavior=(value) + end + + # Experimental. +# If this workflow is the result of a continue-as-new, this field is set to the initial_versioning_behavior +# specified in that command. +# Only used for the initial task of this run and the initial task of any retries of this run. +# Not passed to children or to future continue-as-new. +# +# Note: In the first release of Upgrade-on-CaN, when the only ContinueAsNewVersioningBehavior was AutoUpgrade, +# a non-empty InheritedAutoUpgradeInfo meant that the workflow should start as AutoUpgrade. So for compatibility +# with history events generated during that time, know that an UNSPECIFIED value here is equivalent to AutoUpgrade +# value if the InheritedAutoUpgradeInfo is non-empty. + sig { void } + def clear_continue_as_new_initial_versioning_behavior + 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::Deployment::V1::InheritedAutoUpgradeInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::InheritedAutoUpgradeInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::InheritedAutoUpgradeInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::InheritedAutoUpgradeInfo, 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::Deployment::V1::DeploymentInfo::TaskQueueInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + type: T.nilable(T.any(Symbol, String, Integer)), + first_poller_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + name: "", + type: :TASK_QUEUE_TYPE_UNSPECIFIED, + first_poller_time: nil + ) + end + + sig { returns(String) } + def name + end + + sig { params(value: String).void } + def name=(value) + end + + sig { void } + def clear_name + end + + sig { returns(T.any(Symbol, Integer)) } + def type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def type=(value) + end + + sig { void } + def clear_type + end + + # When server saw the first poller for this task queue in this deployment. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def first_poller_time + end + + # When server saw the first poller for this task queue in this deployment. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def first_poller_time=(value) + end + + # When server saw the first poller for this task queue in this deployment. + sig { void } + def clear_first_poller_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::Deployment::V1::DeploymentInfo::TaskQueueInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::DeploymentInfo::TaskQueueInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::DeploymentInfo::TaskQueueInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::DeploymentInfo::TaskQueueInfo, 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::Deployment::V1::WorkerDeploymentVersionInfo::VersionTaskQueueInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + type: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + name: "", + type: :TASK_QUEUE_TYPE_UNSPECIFIED + ) + end + + sig { returns(String) } + def name + end + + sig { params(value: String).void } + def name=(value) + end + + sig { void } + def clear_name + end + + sig { returns(T.any(Symbol, Integer)) } + def type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def type=(value) + end + + sig { void } + def clear_type + end + + sig { 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::Deployment::V1::WorkerDeploymentVersionInfo::VersionTaskQueueInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo::VersionTaskQueueInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo::VersionTaskQueueInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo::VersionTaskQueueInfo, 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::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + version: T.nilable(String), + status: T.nilable(T.any(Symbol, String, Integer)), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + create_time: T.nilable(Google::Protobuf::Timestamp), + drainage_status: T.nilable(T.any(Symbol, String, Integer)), + drainage_info: T.nilable(Temporalio::Api::Deployment::V1::VersionDrainageInfo), + current_since_time: T.nilable(Google::Protobuf::Timestamp), + ramping_since_time: T.nilable(Google::Protobuf::Timestamp), + routing_update_time: T.nilable(Google::Protobuf::Timestamp), + first_activation_time: T.nilable(Google::Protobuf::Timestamp), + last_current_time: T.nilable(Google::Protobuf::Timestamp), + last_deactivation_time: T.nilable(Google::Protobuf::Timestamp), + compute_config: T.nilable(Temporalio::Api::Compute::V1::ComputeConfigSummary) + ).void + end + def initialize( + version: "", + status: :WORKER_DEPLOYMENT_VERSION_STATUS_UNSPECIFIED, + deployment_version: nil, + create_time: nil, + drainage_status: :VERSION_DRAINAGE_STATUS_UNSPECIFIED, + drainage_info: nil, + current_since_time: nil, + ramping_since_time: nil, + routing_update_time: nil, + first_activation_time: nil, + last_current_time: nil, + last_deactivation_time: nil, + compute_config: nil + ) + end + + # Deprecated. Use `deployment_version`. + sig { returns(String) } + def version + end + + # Deprecated. Use `deployment_version`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `deployment_version`. + sig { void } + def clear_version + end + + # The status of the Worker Deployment Version. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # The status of the Worker Deployment Version. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # The status of the Worker Deployment Version. + sig { void } + def clear_status + end + + # Required. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # Required. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # Required. + sig { void } + def clear_deployment_version + 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 + + # Deprecated. Use `drainage_info` instead. + sig { returns(T.any(Symbol, Integer)) } + def drainage_status + end + + # Deprecated. Use `drainage_info` instead. + sig { params(value: T.any(Symbol, String, Integer)).void } + def drainage_status=(value) + end + + # Deprecated. Use `drainage_info` instead. + sig { void } + def clear_drainage_status + end + + # Information about workflow drainage to help the user determine when it is safe +# to decommission a Version. Not present while version is current or ramping + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::VersionDrainageInfo)) } + def drainage_info + end + + # Information about workflow drainage to help the user determine when it is safe +# to decommission a Version. Not present while version is current or ramping + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::VersionDrainageInfo)).void } + def drainage_info=(value) + end + + # Information about workflow drainage to help the user determine when it is safe +# to decommission a Version. Not present while version is current or ramping + sig { void } + def clear_drainage_info + end + + # Unset if not current. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def current_since_time + end + + # Unset if not current. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def current_since_time=(value) + end + + # Unset if not current. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) + sig { void } + def clear_current_since_time + end + + # Unset if not ramping. Updated when the version first starts ramping, not on each ramp change. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def ramping_since_time + end + + # Unset if not ramping. Updated when the version first starts ramping, not on each ramp change. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def ramping_since_time=(value) + end + + # Unset if not ramping. Updated when the version first starts ramping, not on each ramp change. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: 'Since' captures the field semantics despite being a preposition. --) + sig { void } + def clear_ramping_since_time + end + + # Last time `current_since_time`, `ramping_since_time, or `ramp_percentage` of this version changed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def routing_update_time + end + + # Last time `current_since_time`, `ramping_since_time, or `ramp_percentage` of this version changed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def routing_update_time=(value) + end + + # Last time `current_since_time`, `ramping_since_time, or `ramp_percentage` of this version changed. + sig { void } + def clear_routing_update_time + end + + # Timestamp when this version first became current or ramping. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def first_activation_time + end + + # Timestamp when this version first became current or ramping. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def first_activation_time=(value) + end + + # Timestamp when this version first became current or ramping. + sig { void } + def clear_first_activation_time + end + + # Timestamp when this version last became current. +# Can be used to determine whether a version has ever been Current. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_current_time + end + + # Timestamp when this version last became current. +# Can be used to determine whether a version has ever been Current. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_current_time=(value) + end + + # Timestamp when this version last became current. +# Can be used to determine whether a version has ever been Current. + sig { void } + def clear_last_current_time + end + + # Timestamp when this version last stopped being current or ramping. +# Cleared if the version becomes current or ramping again. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_deactivation_time + end + + # Timestamp when this version last stopped being current or ramping. +# Cleared if the version becomes current or ramping again. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_deactivation_time=(value) + end + + # Timestamp when this version last stopped being current or ramping. +# Cleared if the version becomes current or ramping again. + sig { void } + def clear_last_deactivation_time + end + + sig { returns(T.nilable(Temporalio::Api::Compute::V1::ComputeConfigSummary)) } + def compute_config + end + + sig { params(value: T.nilable(Temporalio::Api::Compute::V1::ComputeConfigSummary)).void } + def compute_config=(value) + end + + sig { void } + def clear_compute_config + 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::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/activity.rbi b/temporalio/rbi/temporalio/api/enums/v1/activity.rbi new file mode 100644 index 00000000..b8805c8d --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/activity.rbi @@ -0,0 +1,62 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/activity.proto +# typed: strict + +module Temporalio::Api::Enums::V1::ActivityExecutionStatus + self::ACTIVITY_EXECUTION_STATUS_UNSPECIFIED = T.let(0, Integer) + self::ACTIVITY_EXECUTION_STATUS_RUNNING = T.let(1, Integer) + self::ACTIVITY_EXECUTION_STATUS_COMPLETED = T.let(2, Integer) + self::ACTIVITY_EXECUTION_STATUS_FAILED = T.let(3, Integer) + self::ACTIVITY_EXECUTION_STATUS_CANCELED = T.let(4, Integer) + self::ACTIVITY_EXECUTION_STATUS_TERMINATED = T.let(5, Integer) + self::ACTIVITY_EXECUTION_STATUS_TIMED_OUT = T.let(6, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ActivityIdReusePolicy + self::ACTIVITY_ID_REUSE_POLICY_UNSPECIFIED = T.let(0, Integer) + self::ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE = T.let(1, Integer) + self::ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY = T.let(2, Integer) + self::ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ActivityIdConflictPolicy + self::ACTIVITY_ID_CONFLICT_POLICY_UNSPECIFIED = T.let(0, Integer) + self::ACTIVITY_ID_CONFLICT_POLICY_FAIL = T.let(1, Integer) + self::ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/batch_operation.rbi b/temporalio/rbi/temporalio/api/enums/v1/batch_operation.rbi new file mode 100644 index 00000000..fe196697 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/batch_operation.rbi @@ -0,0 +1,47 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/batch_operation.proto +# typed: strict + +module Temporalio::Api::Enums::V1::BatchOperationType + self::BATCH_OPERATION_TYPE_UNSPECIFIED = T.let(0, Integer) + self::BATCH_OPERATION_TYPE_TERMINATE = T.let(1, Integer) + self::BATCH_OPERATION_TYPE_CANCEL = T.let(2, Integer) + self::BATCH_OPERATION_TYPE_SIGNAL = T.let(3, Integer) + self::BATCH_OPERATION_TYPE_DELETE = T.let(4, Integer) + self::BATCH_OPERATION_TYPE_RESET = T.let(5, Integer) + self::BATCH_OPERATION_TYPE_UPDATE_EXECUTION_OPTIONS = T.let(6, Integer) + self::BATCH_OPERATION_TYPE_UNPAUSE_ACTIVITY = T.let(7, Integer) + self::BATCH_OPERATION_TYPE_UPDATE_ACTIVITY_OPTIONS = T.let(8, Integer) + self::BATCH_OPERATION_TYPE_RESET_ACTIVITY = T.let(9, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::BatchOperationState + self::BATCH_OPERATION_STATE_UNSPECIFIED = T.let(0, Integer) + self::BATCH_OPERATION_STATE_RUNNING = T.let(1, Integer) + self::BATCH_OPERATION_STATE_COMPLETED = T.let(2, Integer) + self::BATCH_OPERATION_STATE_FAILED = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/command_type.rbi b/temporalio/rbi/temporalio/api/enums/v1/command_type.rbi new file mode 100644 index 00000000..4b8006bb --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/command_type.rbi @@ -0,0 +1,36 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/command_type.proto +# typed: strict + +module Temporalio::Api::Enums::V1::CommandType + self::COMMAND_TYPE_UNSPECIFIED = T.let(0, Integer) + self::COMMAND_TYPE_SCHEDULE_ACTIVITY_TASK = T.let(1, Integer) + self::COMMAND_TYPE_REQUEST_CANCEL_ACTIVITY_TASK = T.let(2, Integer) + self::COMMAND_TYPE_START_TIMER = T.let(3, Integer) + self::COMMAND_TYPE_COMPLETE_WORKFLOW_EXECUTION = T.let(4, Integer) + self::COMMAND_TYPE_FAIL_WORKFLOW_EXECUTION = T.let(5, Integer) + self::COMMAND_TYPE_CANCEL_TIMER = T.let(6, Integer) + self::COMMAND_TYPE_CANCEL_WORKFLOW_EXECUTION = T.let(7, Integer) + self::COMMAND_TYPE_REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION = T.let(8, Integer) + self::COMMAND_TYPE_RECORD_MARKER = T.let(9, Integer) + self::COMMAND_TYPE_CONTINUE_AS_NEW_WORKFLOW_EXECUTION = T.let(10, Integer) + self::COMMAND_TYPE_START_CHILD_WORKFLOW_EXECUTION = T.let(11, Integer) + self::COMMAND_TYPE_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION = T.let(12, Integer) + self::COMMAND_TYPE_UPSERT_WORKFLOW_SEARCH_ATTRIBUTES = T.let(13, Integer) + self::COMMAND_TYPE_PROTOCOL_MESSAGE = T.let(14, Integer) + self::COMMAND_TYPE_MODIFY_WORKFLOW_PROPERTIES = T.let(16, Integer) + self::COMMAND_TYPE_SCHEDULE_NEXUS_OPERATION = T.let(17, Integer) + self::COMMAND_TYPE_REQUEST_CANCEL_NEXUS_OPERATION = T.let(18, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/common.rbi b/temporalio/rbi/temporalio/api/enums/v1/common.rbi new file mode 100644 index 00000000..c79ac548 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/common.rbi @@ -0,0 +1,181 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/common.proto +# typed: strict + +module Temporalio::Api::Enums::V1::EncodingType + self::ENCODING_TYPE_UNSPECIFIED = T.let(0, Integer) + self::ENCODING_TYPE_PROTO3 = T.let(1, Integer) + self::ENCODING_TYPE_JSON = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::IndexedValueType + self::INDEXED_VALUE_TYPE_UNSPECIFIED = T.let(0, Integer) + self::INDEXED_VALUE_TYPE_TEXT = T.let(1, Integer) + self::INDEXED_VALUE_TYPE_KEYWORD = T.let(2, Integer) + self::INDEXED_VALUE_TYPE_INT = T.let(3, Integer) + self::INDEXED_VALUE_TYPE_DOUBLE = T.let(4, Integer) + self::INDEXED_VALUE_TYPE_BOOL = T.let(5, Integer) + self::INDEXED_VALUE_TYPE_DATETIME = T.let(6, Integer) + self::INDEXED_VALUE_TYPE_KEYWORD_LIST = T.let(7, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::Severity + self::SEVERITY_UNSPECIFIED = T.let(0, Integer) + self::SEVERITY_HIGH = T.let(1, Integer) + self::SEVERITY_MEDIUM = T.let(2, Integer) + self::SEVERITY_LOW = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::CallbackState + self::CALLBACK_STATE_UNSPECIFIED = T.let(0, Integer) + self::CALLBACK_STATE_STANDBY = T.let(1, Integer) + self::CALLBACK_STATE_SCHEDULED = T.let(2, Integer) + self::CALLBACK_STATE_BACKING_OFF = T.let(3, Integer) + self::CALLBACK_STATE_FAILED = T.let(4, Integer) + self::CALLBACK_STATE_SUCCEEDED = T.let(5, Integer) + self::CALLBACK_STATE_BLOCKED = T.let(6, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::PendingNexusOperationState + self::PENDING_NEXUS_OPERATION_STATE_UNSPECIFIED = T.let(0, Integer) + self::PENDING_NEXUS_OPERATION_STATE_SCHEDULED = T.let(1, Integer) + self::PENDING_NEXUS_OPERATION_STATE_BACKING_OFF = T.let(2, Integer) + self::PENDING_NEXUS_OPERATION_STATE_STARTED = T.let(3, Integer) + self::PENDING_NEXUS_OPERATION_STATE_BLOCKED = T.let(4, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::NexusOperationCancellationState + self::NEXUS_OPERATION_CANCELLATION_STATE_UNSPECIFIED = T.let(0, Integer) + self::NEXUS_OPERATION_CANCELLATION_STATE_SCHEDULED = T.let(1, Integer) + self::NEXUS_OPERATION_CANCELLATION_STATE_BACKING_OFF = T.let(2, Integer) + self::NEXUS_OPERATION_CANCELLATION_STATE_SUCCEEDED = T.let(3, Integer) + self::NEXUS_OPERATION_CANCELLATION_STATE_FAILED = T.let(4, Integer) + self::NEXUS_OPERATION_CANCELLATION_STATE_TIMED_OUT = T.let(5, Integer) + self::NEXUS_OPERATION_CANCELLATION_STATE_BLOCKED = T.let(6, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::WorkflowRuleActionScope + self::WORKFLOW_RULE_ACTION_SCOPE_UNSPECIFIED = T.let(0, Integer) + self::WORKFLOW_RULE_ACTION_SCOPE_WORKFLOW = T.let(1, Integer) + self::WORKFLOW_RULE_ACTION_SCOPE_ACTIVITY = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ApplicationErrorCategory + self::APPLICATION_ERROR_CATEGORY_UNSPECIFIED = T.let(0, Integer) + self::APPLICATION_ERROR_CATEGORY_BENIGN = T.let(1, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::WorkerStatus + self::WORKER_STATUS_UNSPECIFIED = T.let(0, Integer) + self::WORKER_STATUS_RUNNING = T.let(1, Integer) + self::WORKER_STATUS_SHUTTING_DOWN = T.let(2, Integer) + self::WORKER_STATUS_SHUTDOWN = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/deployment.rbi b/temporalio/rbi/temporalio/api/enums/v1/deployment.rbi new file mode 100644 index 00000000..8defbe47 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/deployment.rbi @@ -0,0 +1,80 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/deployment.proto +# typed: strict + +module Temporalio::Api::Enums::V1::DeploymentReachability + self::DEPLOYMENT_REACHABILITY_UNSPECIFIED = T.let(0, Integer) + self::DEPLOYMENT_REACHABILITY_REACHABLE = T.let(1, Integer) + self::DEPLOYMENT_REACHABILITY_CLOSED_WORKFLOWS_ONLY = T.let(2, Integer) + self::DEPLOYMENT_REACHABILITY_UNREACHABLE = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::VersionDrainageStatus + self::VERSION_DRAINAGE_STATUS_UNSPECIFIED = T.let(0, Integer) + self::VERSION_DRAINAGE_STATUS_DRAINING = T.let(1, Integer) + self::VERSION_DRAINAGE_STATUS_DRAINED = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::WorkerVersioningMode + self::WORKER_VERSIONING_MODE_UNSPECIFIED = T.let(0, Integer) + self::WORKER_VERSIONING_MODE_UNVERSIONED = T.let(1, Integer) + self::WORKER_VERSIONING_MODE_VERSIONED = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::WorkerDeploymentVersionStatus + self::WORKER_DEPLOYMENT_VERSION_STATUS_UNSPECIFIED = T.let(0, Integer) + self::WORKER_DEPLOYMENT_VERSION_STATUS_INACTIVE = T.let(1, Integer) + self::WORKER_DEPLOYMENT_VERSION_STATUS_CURRENT = T.let(2, Integer) + self::WORKER_DEPLOYMENT_VERSION_STATUS_RAMPING = T.let(3, Integer) + self::WORKER_DEPLOYMENT_VERSION_STATUS_DRAINING = T.let(4, Integer) + self::WORKER_DEPLOYMENT_VERSION_STATUS_DRAINED = T.let(5, Integer) + self::WORKER_DEPLOYMENT_VERSION_STATUS_CREATED = T.let(6, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/event_type.rbi b/temporalio/rbi/temporalio/api/enums/v1/event_type.rbi new file mode 100644 index 00000000..a2ba22a1 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/event_type.rbi @@ -0,0 +1,79 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/event_type.proto +# typed: strict + +module Temporalio::Api::Enums::V1::EventType + self::EVENT_TYPE_UNSPECIFIED = T.let(0, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_STARTED = T.let(1, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED = T.let(2, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_FAILED = T.let(3, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_TIMED_OUT = T.let(4, Integer) + self::EVENT_TYPE_WORKFLOW_TASK_SCHEDULED = T.let(5, Integer) + self::EVENT_TYPE_WORKFLOW_TASK_STARTED = T.let(6, Integer) + self::EVENT_TYPE_WORKFLOW_TASK_COMPLETED = T.let(7, Integer) + self::EVENT_TYPE_WORKFLOW_TASK_TIMED_OUT = T.let(8, Integer) + self::EVENT_TYPE_WORKFLOW_TASK_FAILED = T.let(9, Integer) + self::EVENT_TYPE_ACTIVITY_TASK_SCHEDULED = T.let(10, Integer) + self::EVENT_TYPE_ACTIVITY_TASK_STARTED = T.let(11, Integer) + self::EVENT_TYPE_ACTIVITY_TASK_COMPLETED = T.let(12, Integer) + self::EVENT_TYPE_ACTIVITY_TASK_FAILED = T.let(13, Integer) + self::EVENT_TYPE_ACTIVITY_TASK_TIMED_OUT = T.let(14, Integer) + self::EVENT_TYPE_ACTIVITY_TASK_CANCEL_REQUESTED = T.let(15, Integer) + self::EVENT_TYPE_ACTIVITY_TASK_CANCELED = T.let(16, Integer) + self::EVENT_TYPE_TIMER_STARTED = T.let(17, Integer) + self::EVENT_TYPE_TIMER_FIRED = T.let(18, Integer) + self::EVENT_TYPE_TIMER_CANCELED = T.let(19, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_CANCEL_REQUESTED = T.let(20, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED = T.let(21, Integer) + self::EVENT_TYPE_REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED = T.let(22, Integer) + self::EVENT_TYPE_REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED = T.let(23, Integer) + self::EVENT_TYPE_EXTERNAL_WORKFLOW_EXECUTION_CANCEL_REQUESTED = T.let(24, Integer) + self::EVENT_TYPE_MARKER_RECORDED = T.let(25, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED = T.let(26, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_TERMINATED = T.let(27, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_CONTINUED_AS_NEW = T.let(28, Integer) + self::EVENT_TYPE_START_CHILD_WORKFLOW_EXECUTION_INITIATED = T.let(29, Integer) + self::EVENT_TYPE_START_CHILD_WORKFLOW_EXECUTION_FAILED = T.let(30, Integer) + self::EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_STARTED = T.let(31, Integer) + self::EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_COMPLETED = T.let(32, Integer) + self::EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_FAILED = T.let(33, Integer) + self::EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_CANCELED = T.let(34, Integer) + self::EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_TIMED_OUT = T.let(35, Integer) + self::EVENT_TYPE_CHILD_WORKFLOW_EXECUTION_TERMINATED = T.let(36, Integer) + self::EVENT_TYPE_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED = T.let(37, Integer) + self::EVENT_TYPE_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED = T.let(38, Integer) + self::EVENT_TYPE_EXTERNAL_WORKFLOW_EXECUTION_SIGNALED = T.let(39, Integer) + self::EVENT_TYPE_UPSERT_WORKFLOW_SEARCH_ATTRIBUTES = T.let(40, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_UPDATE_ADMITTED = T.let(47, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_UPDATE_ACCEPTED = T.let(41, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_UPDATE_REJECTED = T.let(42, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_UPDATE_COMPLETED = T.let(43, Integer) + self::EVENT_TYPE_WORKFLOW_PROPERTIES_MODIFIED_EXTERNALLY = T.let(44, Integer) + self::EVENT_TYPE_ACTIVITY_PROPERTIES_MODIFIED_EXTERNALLY = T.let(45, Integer) + self::EVENT_TYPE_WORKFLOW_PROPERTIES_MODIFIED = T.let(46, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_SCHEDULED = T.let(48, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_STARTED = T.let(49, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_COMPLETED = T.let(50, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_FAILED = T.let(51, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_CANCELED = T.let(52, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_TIMED_OUT = T.let(53, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_CANCEL_REQUESTED = T.let(54, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_OPTIONS_UPDATED = T.let(55, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_CANCEL_REQUEST_COMPLETED = T.let(56, Integer) + self::EVENT_TYPE_NEXUS_OPERATION_CANCEL_REQUEST_FAILED = T.let(57, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_PAUSED = T.let(58, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_UNPAUSED = T.let(59, Integer) + self::EVENT_TYPE_WORKFLOW_EXECUTION_TIME_SKIPPING_TRANSITIONED = T.let(60, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/failed_cause.rbi b/temporalio/rbi/temporalio/api/enums/v1/failed_cause.rbi new file mode 100644 index 00000000..dc780c52 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/failed_cause.rbi @@ -0,0 +1,155 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/failed_cause.proto +# typed: strict + +module Temporalio::Api::Enums::V1::WorkflowTaskFailedCause + self::WORKFLOW_TASK_FAILED_CAUSE_UNSPECIFIED = T.let(0, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_UNHANDLED_COMMAND = T.let(1, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_SCHEDULE_ACTIVITY_ATTRIBUTES = T.let(2, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_REQUEST_CANCEL_ACTIVITY_ATTRIBUTES = T.let(3, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_START_TIMER_ATTRIBUTES = T.let(4, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_CANCEL_TIMER_ATTRIBUTES = T.let(5, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_RECORD_MARKER_ATTRIBUTES = T.let(6, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_COMPLETE_WORKFLOW_EXECUTION_ATTRIBUTES = T.let(7, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_FAIL_WORKFLOW_EXECUTION_ATTRIBUTES = T.let(8, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_CANCEL_WORKFLOW_EXECUTION_ATTRIBUTES = T.let(9, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_ATTRIBUTES = T.let(10, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_CONTINUE_AS_NEW_ATTRIBUTES = T.let(11, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_START_TIMER_DUPLICATE_ID = T.let(12, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_RESET_STICKY_TASK_QUEUE = T.let(13, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_WORKFLOW_WORKER_UNHANDLED_FAILURE = T.let(14, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_SIGNAL_WORKFLOW_EXECUTION_ATTRIBUTES = T.let(15, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_START_CHILD_EXECUTION_ATTRIBUTES = T.let(16, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_FORCE_CLOSE_COMMAND = T.let(17, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_FAILOVER_CLOSE_COMMAND = T.let(18, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_SIGNAL_INPUT_SIZE = T.let(19, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_RESET_WORKFLOW = T.let(20, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_BINARY = T.let(21, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_SCHEDULE_ACTIVITY_DUPLICATE_ID = T.let(22, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_SEARCH_ATTRIBUTES = T.let(23, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_NON_DETERMINISTIC_ERROR = T.let(24, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_MODIFY_WORKFLOW_PROPERTIES_ATTRIBUTES = T.let(25, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_PENDING_CHILD_WORKFLOWS_LIMIT_EXCEEDED = T.let(26, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_PENDING_ACTIVITIES_LIMIT_EXCEEDED = T.let(27, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_PENDING_SIGNALS_LIMIT_EXCEEDED = T.let(28, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_PENDING_REQUEST_CANCEL_LIMIT_EXCEEDED = T.let(29, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_UPDATE_WORKFLOW_EXECUTION_MESSAGE = T.let(30, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_UNHANDLED_UPDATE = T.let(31, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_SCHEDULE_NEXUS_OPERATION_ATTRIBUTES = T.let(32, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_PENDING_NEXUS_OPERATIONS_LIMIT_EXCEEDED = T.let(33, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_BAD_REQUEST_CANCEL_NEXUS_OPERATION_ATTRIBUTES = T.let(34, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_FEATURE_DISABLED = T.let(35, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_GRPC_MESSAGE_TOO_LARGE = T.let(36, Integer) + self::WORKFLOW_TASK_FAILED_CAUSE_PAYLOADS_TOO_LARGE = T.let(37, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::StartChildWorkflowExecutionFailedCause + self::START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED = T.let(0, Integer) + self::START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_EXISTS = T.let(1, Integer) + self::START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_NAMESPACE_NOT_FOUND = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::CancelExternalWorkflowExecutionFailedCause + self::CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED = T.let(0, Integer) + self::CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_EXTERNAL_WORKFLOW_EXECUTION_NOT_FOUND = T.let(1, Integer) + self::CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_NAMESPACE_NOT_FOUND = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::SignalExternalWorkflowExecutionFailedCause + self::SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED = T.let(0, Integer) + self::SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_EXTERNAL_WORKFLOW_EXECUTION_NOT_FOUND = T.let(1, Integer) + self::SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_NAMESPACE_NOT_FOUND = T.let(2, Integer) + self::SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_SIGNAL_COUNT_LIMIT_EXCEEDED = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ResourceExhaustedCause + self::RESOURCE_EXHAUSTED_CAUSE_UNSPECIFIED = T.let(0, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_RPS_LIMIT = T.let(1, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_CONCURRENT_LIMIT = T.let(2, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_SYSTEM_OVERLOADED = T.let(3, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_PERSISTENCE_LIMIT = T.let(4, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_BUSY_WORKFLOW = T.let(5, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_APS_LIMIT = T.let(6, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_PERSISTENCE_STORAGE_LIMIT = T.let(7, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_CIRCUIT_BREAKER_OPEN = T.let(8, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_OPS_LIMIT = T.let(9, Integer) + self::RESOURCE_EXHAUSTED_CAUSE_WORKER_DEPLOYMENT_LIMITS = T.let(10, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ResourceExhaustedScope + self::RESOURCE_EXHAUSTED_SCOPE_UNSPECIFIED = T.let(0, Integer) + self::RESOURCE_EXHAUSTED_SCOPE_NAMESPACE = T.let(1, Integer) + self::RESOURCE_EXHAUSTED_SCOPE_SYSTEM = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/namespace.rbi b/temporalio/rbi/temporalio/api/enums/v1/namespace.rbi new file mode 100644 index 00000000..78b15e12 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/namespace.rbi @@ -0,0 +1,58 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/namespace.proto +# typed: strict + +module Temporalio::Api::Enums::V1::NamespaceState + self::NAMESPACE_STATE_UNSPECIFIED = T.let(0, Integer) + self::NAMESPACE_STATE_REGISTERED = T.let(1, Integer) + self::NAMESPACE_STATE_DEPRECATED = T.let(2, Integer) + self::NAMESPACE_STATE_DELETED = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ArchivalState + self::ARCHIVAL_STATE_UNSPECIFIED = T.let(0, Integer) + self::ARCHIVAL_STATE_DISABLED = T.let(1, Integer) + self::ARCHIVAL_STATE_ENABLED = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ReplicationState + self::REPLICATION_STATE_UNSPECIFIED = T.let(0, Integer) + self::REPLICATION_STATE_NORMAL = T.let(1, Integer) + self::REPLICATION_STATE_HANDOVER = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/nexus.rbi b/temporalio/rbi/temporalio/api/enums/v1/nexus.rbi new file mode 100644 index 00000000..98f01b87 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/nexus.rbi @@ -0,0 +1,98 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/nexus.proto +# typed: strict + +module Temporalio::Api::Enums::V1::NexusHandlerErrorRetryBehavior + self::NEXUS_HANDLER_ERROR_RETRY_BEHAVIOR_UNSPECIFIED = T.let(0, Integer) + self::NEXUS_HANDLER_ERROR_RETRY_BEHAVIOR_RETRYABLE = T.let(1, Integer) + self::NEXUS_HANDLER_ERROR_RETRY_BEHAVIOR_NON_RETRYABLE = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::NexusOperationExecutionStatus + self::NEXUS_OPERATION_EXECUTION_STATUS_UNSPECIFIED = T.let(0, Integer) + self::NEXUS_OPERATION_EXECUTION_STATUS_RUNNING = T.let(1, Integer) + self::NEXUS_OPERATION_EXECUTION_STATUS_COMPLETED = T.let(2, Integer) + self::NEXUS_OPERATION_EXECUTION_STATUS_FAILED = T.let(3, Integer) + self::NEXUS_OPERATION_EXECUTION_STATUS_CANCELED = T.let(4, Integer) + self::NEXUS_OPERATION_EXECUTION_STATUS_TERMINATED = T.let(5, Integer) + self::NEXUS_OPERATION_EXECUTION_STATUS_TIMED_OUT = T.let(6, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::NexusOperationWaitStage + self::NEXUS_OPERATION_WAIT_STAGE_UNSPECIFIED = T.let(0, Integer) + self::NEXUS_OPERATION_WAIT_STAGE_STARTED = T.let(1, Integer) + self::NEXUS_OPERATION_WAIT_STAGE_CLOSED = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::NexusOperationIdReusePolicy + self::NEXUS_OPERATION_ID_REUSE_POLICY_UNSPECIFIED = T.let(0, Integer) + self::NEXUS_OPERATION_ID_REUSE_POLICY_ALLOW_DUPLICATE = T.let(1, Integer) + self::NEXUS_OPERATION_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY = T.let(2, Integer) + self::NEXUS_OPERATION_ID_REUSE_POLICY_REJECT_DUPLICATE = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::NexusOperationIdConflictPolicy + self::NEXUS_OPERATION_ID_CONFLICT_POLICY_UNSPECIFIED = T.let(0, Integer) + self::NEXUS_OPERATION_ID_CONFLICT_POLICY_FAIL = T.let(1, Integer) + self::NEXUS_OPERATION_ID_CONFLICT_POLICY_USE_EXISTING = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/query.rbi b/temporalio/rbi/temporalio/api/enums/v1/query.rbi new file mode 100644 index 00000000..abc70ba5 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/query.rbi @@ -0,0 +1,40 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/query.proto +# typed: strict + +module Temporalio::Api::Enums::V1::QueryResultType + self::QUERY_RESULT_TYPE_UNSPECIFIED = T.let(0, Integer) + self::QUERY_RESULT_TYPE_ANSWERED = T.let(1, Integer) + self::QUERY_RESULT_TYPE_FAILED = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::QueryRejectCondition + self::QUERY_REJECT_CONDITION_UNSPECIFIED = T.let(0, Integer) + self::QUERY_REJECT_CONDITION_NONE = T.let(1, Integer) + self::QUERY_REJECT_CONDITION_NOT_OPEN = T.let(2, Integer) + self::QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/reset.rbi b/temporalio/rbi/temporalio/api/enums/v1/reset.rbi new file mode 100644 index 00000000..c1952ae6 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/reset.rbi @@ -0,0 +1,60 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/reset.proto +# typed: strict + +module Temporalio::Api::Enums::V1::ResetReapplyExcludeType + self::RESET_REAPPLY_EXCLUDE_TYPE_UNSPECIFIED = T.let(0, Integer) + self::RESET_REAPPLY_EXCLUDE_TYPE_SIGNAL = T.let(1, Integer) + self::RESET_REAPPLY_EXCLUDE_TYPE_UPDATE = T.let(2, Integer) + self::RESET_REAPPLY_EXCLUDE_TYPE_NEXUS = T.let(3, Integer) + self::RESET_REAPPLY_EXCLUDE_TYPE_CANCEL_REQUEST = T.let(4, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ResetReapplyType + self::RESET_REAPPLY_TYPE_UNSPECIFIED = T.let(0, Integer) + self::RESET_REAPPLY_TYPE_SIGNAL = T.let(1, Integer) + self::RESET_REAPPLY_TYPE_NONE = T.let(2, Integer) + self::RESET_REAPPLY_TYPE_ALL_ELIGIBLE = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ResetType + self::RESET_TYPE_UNSPECIFIED = T.let(0, Integer) + self::RESET_TYPE_FIRST_WORKFLOW_TASK = T.let(1, Integer) + self::RESET_TYPE_LAST_WORKFLOW_TASK = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/schedule.rbi b/temporalio/rbi/temporalio/api/enums/v1/schedule.rbi new file mode 100644 index 00000000..1992205b --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/schedule.rbi @@ -0,0 +1,25 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/schedule.proto +# typed: strict + +module Temporalio::Api::Enums::V1::ScheduleOverlapPolicy + self::SCHEDULE_OVERLAP_POLICY_UNSPECIFIED = T.let(0, Integer) + self::SCHEDULE_OVERLAP_POLICY_SKIP = T.let(1, Integer) + self::SCHEDULE_OVERLAP_POLICY_BUFFER_ONE = T.let(2, Integer) + self::SCHEDULE_OVERLAP_POLICY_BUFFER_ALL = T.let(3, Integer) + self::SCHEDULE_OVERLAP_POLICY_CANCEL_OTHER = T.let(4, Integer) + self::SCHEDULE_OVERLAP_POLICY_TERMINATE_OTHER = T.let(5, Integer) + self::SCHEDULE_OVERLAP_POLICY_ALLOW_ALL = T.let(6, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/task_queue.rbi b/temporalio/rbi/temporalio/api/enums/v1/task_queue.rbi new file mode 100644 index 00000000..e5a24be8 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/task_queue.rbi @@ -0,0 +1,134 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/task_queue.proto +# typed: strict + +module Temporalio::Api::Enums::V1::TaskQueueKind + self::TASK_QUEUE_KIND_UNSPECIFIED = T.let(0, Integer) + self::TASK_QUEUE_KIND_NORMAL = T.let(1, Integer) + self::TASK_QUEUE_KIND_STICKY = T.let(2, Integer) + self::TASK_QUEUE_KIND_WORKER_COMMANDS = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::TaskQueueType + self::TASK_QUEUE_TYPE_UNSPECIFIED = T.let(0, Integer) + self::TASK_QUEUE_TYPE_WORKFLOW = T.let(1, Integer) + self::TASK_QUEUE_TYPE_ACTIVITY = T.let(2, Integer) + self::TASK_QUEUE_TYPE_NEXUS = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::TaskReachability + self::TASK_REACHABILITY_UNSPECIFIED = T.let(0, Integer) + self::TASK_REACHABILITY_NEW_WORKFLOWS = T.let(1, Integer) + self::TASK_REACHABILITY_EXISTING_WORKFLOWS = T.let(2, Integer) + self::TASK_REACHABILITY_OPEN_WORKFLOWS = T.let(3, Integer) + self::TASK_REACHABILITY_CLOSED_WORKFLOWS = T.let(4, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::BuildIdTaskReachability + self::BUILD_ID_TASK_REACHABILITY_UNSPECIFIED = T.let(0, Integer) + self::BUILD_ID_TASK_REACHABILITY_REACHABLE = T.let(1, Integer) + self::BUILD_ID_TASK_REACHABILITY_CLOSED_WORKFLOWS_ONLY = T.let(2, Integer) + self::BUILD_ID_TASK_REACHABILITY_UNREACHABLE = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::DescribeTaskQueueMode + self::DESCRIBE_TASK_QUEUE_MODE_UNSPECIFIED = T.let(0, Integer) + self::DESCRIBE_TASK_QUEUE_MODE_ENHANCED = T.let(1, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::RateLimitSource + self::RATE_LIMIT_SOURCE_UNSPECIFIED = T.let(0, Integer) + self::RATE_LIMIT_SOURCE_API = T.let(1, Integer) + self::RATE_LIMIT_SOURCE_WORKER = T.let(2, Integer) + self::RATE_LIMIT_SOURCE_SYSTEM = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::RoutingConfigUpdateState + self::ROUTING_CONFIG_UPDATE_STATE_UNSPECIFIED = T.let(0, Integer) + self::ROUTING_CONFIG_UPDATE_STATE_IN_PROGRESS = T.let(1, Integer) + self::ROUTING_CONFIG_UPDATE_STATE_COMPLETED = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/update.rbi b/temporalio/rbi/temporalio/api/enums/v1/update.rbi new file mode 100644 index 00000000..017924f3 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/update.rbi @@ -0,0 +1,39 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/update.proto +# typed: strict + +module Temporalio::Api::Enums::V1::UpdateWorkflowExecutionLifecycleStage + self::UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED = T.let(0, Integer) + self::UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ADMITTED = T.let(1, Integer) + self::UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED = T.let(2, Integer) + self::UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_COMPLETED = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::UpdateAdmittedEventOrigin + self::UPDATE_ADMITTED_EVENT_ORIGIN_UNSPECIFIED = T.let(0, Integer) + self::UPDATE_ADMITTED_EVENT_ORIGIN_REAPPLY = T.let(1, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/enums/v1/workflow.rbi b/temporalio/rbi/temporalio/api/enums/v1/workflow.rbi new file mode 100644 index 00000000..c19f11b1 --- /dev/null +++ b/temporalio/rbi/temporalio/api/enums/v1/workflow.rbi @@ -0,0 +1,259 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/enums/v1/workflow.proto +# typed: strict + +module Temporalio::Api::Enums::V1::WorkflowIdReusePolicy + self::WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED = T.let(0, Integer) + self::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE = T.let(1, Integer) + self::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY = T.let(2, Integer) + self::WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE = T.let(3, Integer) + self::WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING = T.let(4, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::WorkflowIdConflictPolicy + self::WORKFLOW_ID_CONFLICT_POLICY_UNSPECIFIED = T.let(0, Integer) + self::WORKFLOW_ID_CONFLICT_POLICY_FAIL = T.let(1, Integer) + self::WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING = T.let(2, Integer) + self::WORKFLOW_ID_CONFLICT_POLICY_TERMINATE_EXISTING = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ParentClosePolicy + self::PARENT_CLOSE_POLICY_UNSPECIFIED = T.let(0, Integer) + self::PARENT_CLOSE_POLICY_TERMINATE = T.let(1, Integer) + self::PARENT_CLOSE_POLICY_ABANDON = T.let(2, Integer) + self::PARENT_CLOSE_POLICY_REQUEST_CANCEL = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ContinueAsNewInitiator + self::CONTINUE_AS_NEW_INITIATOR_UNSPECIFIED = T.let(0, Integer) + self::CONTINUE_AS_NEW_INITIATOR_WORKFLOW = T.let(1, Integer) + self::CONTINUE_AS_NEW_INITIATOR_RETRY = T.let(2, Integer) + self::CONTINUE_AS_NEW_INITIATOR_CRON_SCHEDULE = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::WorkflowExecutionStatus + self::WORKFLOW_EXECUTION_STATUS_UNSPECIFIED = T.let(0, Integer) + self::WORKFLOW_EXECUTION_STATUS_RUNNING = T.let(1, Integer) + self::WORKFLOW_EXECUTION_STATUS_COMPLETED = T.let(2, Integer) + self::WORKFLOW_EXECUTION_STATUS_FAILED = T.let(3, Integer) + self::WORKFLOW_EXECUTION_STATUS_CANCELED = T.let(4, Integer) + self::WORKFLOW_EXECUTION_STATUS_TERMINATED = T.let(5, Integer) + self::WORKFLOW_EXECUTION_STATUS_CONTINUED_AS_NEW = T.let(6, Integer) + self::WORKFLOW_EXECUTION_STATUS_TIMED_OUT = T.let(7, Integer) + self::WORKFLOW_EXECUTION_STATUS_PAUSED = T.let(8, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::PendingActivityState + self::PENDING_ACTIVITY_STATE_UNSPECIFIED = T.let(0, Integer) + self::PENDING_ACTIVITY_STATE_SCHEDULED = T.let(1, Integer) + self::PENDING_ACTIVITY_STATE_STARTED = T.let(2, Integer) + self::PENDING_ACTIVITY_STATE_CANCEL_REQUESTED = T.let(3, Integer) + self::PENDING_ACTIVITY_STATE_PAUSED = T.let(4, Integer) + self::PENDING_ACTIVITY_STATE_PAUSE_REQUESTED = T.let(5, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::PendingWorkflowTaskState + self::PENDING_WORKFLOW_TASK_STATE_UNSPECIFIED = T.let(0, Integer) + self::PENDING_WORKFLOW_TASK_STATE_SCHEDULED = T.let(1, Integer) + self::PENDING_WORKFLOW_TASK_STATE_STARTED = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::HistoryEventFilterType + self::HISTORY_EVENT_FILTER_TYPE_UNSPECIFIED = T.let(0, Integer) + self::HISTORY_EVENT_FILTER_TYPE_ALL_EVENT = T.let(1, Integer) + self::HISTORY_EVENT_FILTER_TYPE_CLOSE_EVENT = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::RetryState + self::RETRY_STATE_UNSPECIFIED = T.let(0, Integer) + self::RETRY_STATE_IN_PROGRESS = T.let(1, Integer) + self::RETRY_STATE_NON_RETRYABLE_FAILURE = T.let(2, Integer) + self::RETRY_STATE_TIMEOUT = T.let(3, Integer) + self::RETRY_STATE_MAXIMUM_ATTEMPTS_REACHED = T.let(4, Integer) + self::RETRY_STATE_RETRY_POLICY_NOT_SET = T.let(5, Integer) + self::RETRY_STATE_INTERNAL_SERVER_ERROR = T.let(6, Integer) + self::RETRY_STATE_CANCEL_REQUESTED = T.let(7, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::TimeoutType + self::TIMEOUT_TYPE_UNSPECIFIED = T.let(0, Integer) + self::TIMEOUT_TYPE_START_TO_CLOSE = T.let(1, Integer) + self::TIMEOUT_TYPE_SCHEDULE_TO_START = T.let(2, Integer) + self::TIMEOUT_TYPE_SCHEDULE_TO_CLOSE = T.let(3, Integer) + self::TIMEOUT_TYPE_HEARTBEAT = T.let(4, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::VersioningBehavior + self::VERSIONING_BEHAVIOR_UNSPECIFIED = T.let(0, Integer) + self::VERSIONING_BEHAVIOR_PINNED = T.let(1, Integer) + self::VERSIONING_BEHAVIOR_AUTO_UPGRADE = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::ContinueAsNewVersioningBehavior + self::CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_UNSPECIFIED = T.let(0, Integer) + self::CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_AUTO_UPGRADE = T.let(1, Integer) + self::CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_USE_RAMPING_VERSION = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Enums::V1::SuggestContinueAsNewReason + self::SUGGEST_CONTINUE_AS_NEW_REASON_UNSPECIFIED = T.let(0, Integer) + self::SUGGEST_CONTINUE_AS_NEW_REASON_HISTORY_SIZE_TOO_LARGE = T.let(1, Integer) + self::SUGGEST_CONTINUE_AS_NEW_REASON_TOO_MANY_HISTORY_EVENTS = T.let(2, Integer) + self::SUGGEST_CONTINUE_AS_NEW_REASON_TOO_MANY_UPDATES = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/errordetails/v1/message.rbi b/temporalio/rbi/temporalio/api/errordetails/v1/message.rbi new file mode 100644 index 00000000..98067d06 --- /dev/null +++ b/temporalio/rbi/temporalio/api/errordetails/v1/message.rbi @@ -0,0 +1,1389 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/errordetails/v1/message.proto +# typed: strict + +class Temporalio::Api::ErrorDetails::V1::NotFoundFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + current_cluster: T.nilable(String), + active_cluster: T.nilable(String) + ).void + end + def initialize( + current_cluster: "", + active_cluster: "" + ) + end + + sig { returns(String) } + def current_cluster + end + + sig { params(value: String).void } + def current_cluster=(value) + end + + sig { void } + def clear_current_cluster + end + + sig { returns(String) } + def active_cluster + end + + sig { params(value: String).void } + def active_cluster=(value) + end + + sig { void } + def clear_active_cluster + 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::ErrorDetails::V1::NotFoundFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NotFoundFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::NotFoundFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NotFoundFailure, 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::ErrorDetails::V1::WorkflowExecutionAlreadyStartedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_request_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + start_request_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def start_request_id + end + + sig { params(value: String).void } + def start_request_id=(value) + end + + sig { void } + def clear_start_request_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::ErrorDetails::V1::WorkflowExecutionAlreadyStartedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::WorkflowExecutionAlreadyStartedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::WorkflowExecutionAlreadyStartedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::WorkflowExecutionAlreadyStartedFailure, 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::ErrorDetails::V1::NamespaceNotActiveFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + current_cluster: T.nilable(String), + active_cluster: T.nilable(String) + ).void + end + def initialize( + namespace: "", + current_cluster: "", + active_cluster: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def current_cluster + end + + sig { params(value: String).void } + def current_cluster=(value) + end + + sig { void } + def clear_current_cluster + end + + sig { returns(String) } + def active_cluster + end + + sig { params(value: String).void } + def active_cluster=(value) + end + + sig { void } + def clear_active_cluster + 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::ErrorDetails::V1::NamespaceNotActiveFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceNotActiveFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::NamespaceNotActiveFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceNotActiveFailure, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# NamespaceUnavailableFailure is returned by the service when a request addresses a namespace that is unavailable. For +# example, when a namespace is in the process of failing over between clusters. +# This is a transient error that should be automatically retried by clients. +class Temporalio::Api::ErrorDetails::V1::NamespaceUnavailableFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String) + ).void + end + def initialize( + namespace: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + 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::ErrorDetails::V1::NamespaceUnavailableFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceUnavailableFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::NamespaceUnavailableFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceUnavailableFailure, 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::ErrorDetails::V1::NamespaceInvalidStateFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + allowed_states: T.nilable(T::Array[T.any(Symbol, String, Integer)]) + ).void + end + def initialize( + namespace: "", + state: :NAMESPACE_STATE_UNSPECIFIED, + allowed_states: [] + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Current state of the requested namespace. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # Current state of the requested namespace. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # Current state of the requested namespace. + sig { void } + def clear_state + end + + # Allowed namespace states for requested operation. +# For example NAMESPACE_STATE_DELETED is forbidden for most operations but allowed for DescribeNamespace. + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def allowed_states + end + + # Allowed namespace states for requested operation. +# For example NAMESPACE_STATE_DELETED is forbidden for most operations but allowed for DescribeNamespace. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def allowed_states=(value) + end + + # Allowed namespace states for requested operation. +# For example NAMESPACE_STATE_DELETED is forbidden for most operations but allowed for DescribeNamespace. + sig { void } + def clear_allowed_states + 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::ErrorDetails::V1::NamespaceInvalidStateFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceInvalidStateFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::NamespaceInvalidStateFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceInvalidStateFailure, 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::ErrorDetails::V1::NamespaceNotFoundFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String) + ).void + end + def initialize( + namespace: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + 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::ErrorDetails::V1::NamespaceNotFoundFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceNotFoundFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::NamespaceNotFoundFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceNotFoundFailure, 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::ErrorDetails::V1::NamespaceAlreadyExistsFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::ErrorDetails::V1::NamespaceAlreadyExistsFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceAlreadyExistsFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::NamespaceAlreadyExistsFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NamespaceAlreadyExistsFailure, 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::ErrorDetails::V1::ClientVersionNotSupportedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + client_version: T.nilable(String), + client_name: T.nilable(String), + supported_versions: T.nilable(String) + ).void + end + def initialize( + client_version: "", + client_name: "", + supported_versions: "" + ) + end + + sig { returns(String) } + def client_version + end + + sig { params(value: String).void } + def client_version=(value) + end + + sig { void } + def clear_client_version + end + + sig { returns(String) } + def client_name + end + + sig { params(value: String).void } + def client_name=(value) + end + + sig { void } + def clear_client_name + end + + sig { returns(String) } + def supported_versions + end + + sig { params(value: String).void } + def supported_versions=(value) + end + + sig { void } + def clear_supported_versions + 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::ErrorDetails::V1::ClientVersionNotSupportedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::ClientVersionNotSupportedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::ClientVersionNotSupportedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::ClientVersionNotSupportedFailure, 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::ErrorDetails::V1::ServerVersionNotSupportedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + server_version: T.nilable(String), + client_supported_server_versions: T.nilable(String) + ).void + end + def initialize( + server_version: "", + client_supported_server_versions: "" + ) + end + + sig { returns(String) } + def server_version + end + + sig { params(value: String).void } + def server_version=(value) + end + + sig { void } + def clear_server_version + end + + sig { returns(String) } + def client_supported_server_versions + end + + sig { params(value: String).void } + def client_supported_server_versions=(value) + end + + sig { void } + def clear_client_supported_server_versions + 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::ErrorDetails::V1::ServerVersionNotSupportedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::ServerVersionNotSupportedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::ServerVersionNotSupportedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::ServerVersionNotSupportedFailure, 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::ErrorDetails::V1::CancellationAlreadyRequestedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::ErrorDetails::V1::CancellationAlreadyRequestedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::CancellationAlreadyRequestedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::CancellationAlreadyRequestedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::CancellationAlreadyRequestedFailure, 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::ErrorDetails::V1::QueryFailedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + failure: nil + ) + end + + # The full reason for this query failure. May not be available if the response is generated by an old +# SDK. This field can be encoded by the SDK's failure converter to support E2E encryption of messages and stack +# traces. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The full reason for this query failure. May not be available if the response is generated by an old +# SDK. This field can be encoded by the SDK's failure converter to support E2E encryption of messages and stack +# traces. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The full reason for this query failure. May not be available if the response is generated by an old +# SDK. This field can be encoded by the SDK's failure converter to support E2E encryption of messages and stack +# traces. + sig { void } + def clear_failure + 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::ErrorDetails::V1::QueryFailedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::QueryFailedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::QueryFailedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::QueryFailedFailure, 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::ErrorDetails::V1::PermissionDeniedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + reason: T.nilable(String) + ).void + end + def initialize( + reason: "" + ) + end + + sig { returns(String) } + def reason + end + + sig { params(value: String).void } + def reason=(value) + end + + sig { void } + def clear_reason + 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::ErrorDetails::V1::PermissionDeniedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::PermissionDeniedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::PermissionDeniedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::PermissionDeniedFailure, 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::ErrorDetails::V1::ResourceExhaustedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cause: T.nilable(T.any(Symbol, String, Integer)), + scope: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + cause: :RESOURCE_EXHAUSTED_CAUSE_UNSPECIFIED, + scope: :RESOURCE_EXHAUSTED_SCOPE_UNSPECIFIED + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def cause + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def cause=(value) + end + + sig { void } + def clear_cause + end + + sig { returns(T.any(Symbol, Integer)) } + def scope + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def scope=(value) + end + + sig { void } + def clear_scope + 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::ErrorDetails::V1::ResourceExhaustedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::ResourceExhaustedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::ResourceExhaustedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::ResourceExhaustedFailure, 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::ErrorDetails::V1::SystemWorkflowFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_error: T.nilable(String) + ).void + end + def initialize( + workflow_execution: nil, + workflow_error: "" + ) + end + + # WorkflowId and RunId of the Temporal system workflow performing the underlying operation. +# Looking up the info of the system workflow run may help identify the issue causing the failure. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + # WorkflowId and RunId of the Temporal system workflow performing the underlying operation. +# Looking up the info of the system workflow run may help identify the issue causing the failure. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + # WorkflowId and RunId of the Temporal system workflow performing the underlying operation. +# Looking up the info of the system workflow run may help identify the issue causing the failure. + sig { void } + def clear_workflow_execution + end + + # Serialized error returned by the system workflow performing the underlying operation. + sig { returns(String) } + def workflow_error + end + + # Serialized error returned by the system workflow performing the underlying operation. + sig { params(value: String).void } + def workflow_error=(value) + end + + # Serialized error returned by the system workflow performing the underlying operation. + sig { void } + def clear_workflow_error + 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::ErrorDetails::V1::SystemWorkflowFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::SystemWorkflowFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::SystemWorkflowFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::SystemWorkflowFailure, 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::ErrorDetails::V1::WorkflowNotReadyFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::ErrorDetails::V1::WorkflowNotReadyFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::WorkflowNotReadyFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::WorkflowNotReadyFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::WorkflowNotReadyFailure, 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::ErrorDetails::V1::NewerBuildExistsFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + default_build_id: T.nilable(String) + ).void + end + def initialize( + default_build_id: "" + ) + end + + # The current default compatible build ID which will receive tasks + sig { returns(String) } + def default_build_id + end + + # The current default compatible build ID which will receive tasks + sig { params(value: String).void } + def default_build_id=(value) + end + + # The current default compatible build ID which will receive tasks + sig { void } + def clear_default_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::ErrorDetails::V1::NewerBuildExistsFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NewerBuildExistsFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::NewerBuildExistsFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NewerBuildExistsFailure, 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::ErrorDetails::V1::MultiOperationExecutionFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + statuses: T.nilable(T::Array[T.nilable(Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure::OperationStatus)]) + ).void + end + def initialize( + statuses: [] + ) + end + + # One status for each requested operation from the failed MultiOperation. The failed +# operation(s) have the same error details as if it was executed separately. All other operations have the +# status code `Aborted` and `MultiOperationExecutionAborted` is added to the details field. + sig { returns(T::Array[T.nilable(Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure::OperationStatus)]) } + def statuses + end + + # One status for each requested operation from the failed MultiOperation. The failed +# operation(s) have the same error details as if it was executed separately. All other operations have the +# status code `Aborted` and `MultiOperationExecutionAborted` is added to the details field. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def statuses=(value) + end + + # One status for each requested operation from the failed MultiOperation. The failed +# operation(s) have the same error details as if it was executed separately. All other operations have the +# status code `Aborted` and `MultiOperationExecutionAborted` is added to the details field. + sig { void } + def clear_statuses + 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::ErrorDetails::V1::MultiOperationExecutionFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# An error indicating that an activity execution failed to start. Returned when there is an existing activity with the +# given activity ID, and the given ID reuse and conflict policies do not permit starting a new one or attaching to an +# existing one. +class Temporalio::Api::ErrorDetails::V1::ActivityExecutionAlreadyStartedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_request_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + start_request_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def start_request_id + end + + sig { params(value: String).void } + def start_request_id=(value) + end + + sig { void } + def clear_start_request_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::ErrorDetails::V1::ActivityExecutionAlreadyStartedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::ActivityExecutionAlreadyStartedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::ActivityExecutionAlreadyStartedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::ActivityExecutionAlreadyStartedFailure, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# An error indicating that a Nexus operation failed to start. Returned when there is an existing operation with the +# given operation ID, and the given ID reuse and conflict policies do not permit starting a new one or attaching to an +# existing one. +class Temporalio::Api::ErrorDetails::V1::NexusOperationExecutionAlreadyStartedFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_request_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + start_request_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def start_request_id + end + + sig { params(value: String).void } + def start_request_id=(value) + end + + sig { void } + def clear_start_request_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::ErrorDetails::V1::NexusOperationExecutionAlreadyStartedFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NexusOperationExecutionAlreadyStartedFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::NexusOperationExecutionAlreadyStartedFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::NexusOperationExecutionAlreadyStartedFailure, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# NOTE: `OperationStatus` is modelled after +# [`google.rpc.Status`](https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto). +# +# (-- api-linter: core::0146::any=disabled +# aip.dev/not-precedent: details are meant to hold arbitrary payloads. --) +class Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure::OperationStatus + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + code: T.nilable(Integer), + message: T.nilable(String), + details: T.nilable(T::Array[T.nilable(Google::Protobuf::Any)]) + ).void + end + def initialize( + code: 0, + message: "", + details: [] + ) + end + + sig { returns(Integer) } + def code + end + + sig { params(value: Integer).void } + def code=(value) + end + + sig { void } + def clear_code + end + + sig { returns(String) } + def message + end + + sig { params(value: String).void } + def message=(value) + end + + sig { void } + def clear_message + end + + sig { returns(T::Array[T.nilable(Google::Protobuf::Any)]) } + def details + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def details=(value) + end + + sig { void } + def clear_details + 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::ErrorDetails::V1::MultiOperationExecutionFailure::OperationStatus) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure::OperationStatus).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure::OperationStatus) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::ErrorDetails::V1::MultiOperationExecutionFailure::OperationStatus, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/export/v1/message.rbi b/temporalio/rbi/temporalio/api/export/v1/message.rbi new file mode 100644 index 00000000..8b3efc3f --- /dev/null +++ b/temporalio/rbi/temporalio/api/export/v1/message.rbi @@ -0,0 +1,123 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/export/v1/message.proto +# typed: strict + +class Temporalio::Api::Export::V1::WorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + history: T.nilable(Temporalio::Api::History::V1::History) + ).void + end + def initialize( + history: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::History)) } + def history + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::History)).void } + def history=(value) + end + + sig { void } + def clear_history + 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::Export::V1::WorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Export::V1::WorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Export::V1::WorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Export::V1::WorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# WorkflowExecutions is used by the Cloud Export feature to deserialize +# the exported file. It encapsulates a collection of workflow execution information. +class Temporalio::Api::Export::V1::WorkflowExecutions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + items: T.nilable(T::Array[T.nilable(Temporalio::Api::Export::V1::WorkflowExecution)]) + ).void + end + def initialize( + items: [] + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Export::V1::WorkflowExecution)]) } + def items + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def items=(value) + end + + sig { void } + def clear_items + 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::Export::V1::WorkflowExecutions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Export::V1::WorkflowExecutions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Export::V1::WorkflowExecutions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Export::V1::WorkflowExecutions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/failure/v1/message.rbi b/temporalio/rbi/temporalio/api/failure/v1/message.rbi new file mode 100644 index 00000000..42dc8bc1 --- /dev/null +++ b/temporalio/rbi/temporalio/api/failure/v1/message.rbi @@ -0,0 +1,1303 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/failure/v1/message.proto +# typed: strict + +class Temporalio::Api::Failure::V1::ApplicationFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(String), + non_retryable: T.nilable(T::Boolean), + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + next_retry_delay: T.nilable(Google::Protobuf::Duration), + category: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + type: "", + non_retryable: false, + details: nil, + next_retry_delay: nil, + category: :APPLICATION_ERROR_CATEGORY_UNSPECIFIED + ) + end + + sig { returns(String) } + def type + end + + sig { params(value: String).void } + def type=(value) + end + + sig { void } + def clear_type + end + + sig { returns(T::Boolean) } + def non_retryable + end + + sig { params(value: T::Boolean).void } + def non_retryable=(value) + end + + sig { void } + def clear_non_retryable + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + sig { void } + def clear_details + end + + # next_retry_delay can be used by the client to override the activity +# retry interval calculated by the retry policy. Retry attempts will +# still be subject to the maximum retries limit and total time limit +# defined by the policy. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def next_retry_delay + end + + # next_retry_delay can be used by the client to override the activity +# retry interval calculated by the retry policy. Retry attempts will +# still be subject to the maximum retries limit and total time limit +# defined by the policy. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def next_retry_delay=(value) + end + + # next_retry_delay can be used by the client to override the activity +# retry interval calculated by the retry policy. Retry attempts will +# still be subject to the maximum retries limit and total time limit +# defined by the policy. + sig { void } + def clear_next_retry_delay + end + + sig { returns(T.any(Symbol, Integer)) } + def category + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def category=(value) + end + + sig { void } + def clear_category + 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::Failure::V1::ApplicationFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ApplicationFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::ApplicationFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ApplicationFailureInfo, 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::Failure::V1::TimeoutFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + timeout_type: T.nilable(T.any(Symbol, String, Integer)), + last_heartbeat_details: T.nilable(Temporalio::Api::Common::V1::Payloads) + ).void + end + def initialize( + timeout_type: :TIMEOUT_TYPE_UNSPECIFIED, + last_heartbeat_details: nil + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def timeout_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def timeout_type=(value) + end + + sig { void } + def clear_timeout_type + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_heartbeat_details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_heartbeat_details=(value) + end + + sig { void } + def clear_last_heartbeat_details + 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::Failure::V1::TimeoutFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::TimeoutFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::TimeoutFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::TimeoutFailureInfo, 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::Failure::V1::CanceledFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String) + ).void + end + def initialize( + details: nil, + identity: "" + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + sig { void } + def clear_details + end + + # The identity of the worker or client that requested the cancellation. + sig { returns(String) } + def identity + end + + # The identity of the worker or client that requested the cancellation. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker or client that requested the cancellation. + sig { void } + def clear_identity + 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::Failure::V1::CanceledFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::CanceledFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::CanceledFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::CanceledFailureInfo, 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::Failure::V1::TerminatedFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String) + ).void + end + def initialize( + identity: "" + ) + end + + # The identity of the worker or client that requested the termination. + sig { returns(String) } + def identity + end + + # The identity of the worker or client that requested the termination. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker or client that requested the termination. + sig { void } + def clear_identity + 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::Failure::V1::TerminatedFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::TerminatedFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::TerminatedFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::TerminatedFailureInfo, 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::Failure::V1::ServerFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + non_retryable: T.nilable(T::Boolean) + ).void + end + def initialize( + non_retryable: false + ) + end + + sig { returns(T::Boolean) } + def non_retryable + end + + sig { params(value: T::Boolean).void } + def non_retryable=(value) + end + + sig { void } + def clear_non_retryable + 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::Failure::V1::ServerFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ServerFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::ServerFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ServerFailureInfo, 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::Failure::V1::ResetWorkflowFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + last_heartbeat_details: T.nilable(Temporalio::Api::Common::V1::Payloads) + ).void + end + def initialize( + last_heartbeat_details: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_heartbeat_details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_heartbeat_details=(value) + end + + sig { void } + def clear_last_heartbeat_details + 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::Failure::V1::ResetWorkflowFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ResetWorkflowFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::ResetWorkflowFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ResetWorkflowFailureInfo, 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::Failure::V1::ActivityFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + identity: T.nilable(String), + activity_type: T.nilable(Temporalio::Api::Common::V1::ActivityType), + activity_id: T.nilable(String), + retry_state: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + scheduled_event_id: 0, + started_event_id: 0, + identity: "", + activity_type: nil, + activity_id: "", + retry_state: :RETRY_STATE_UNSPECIFIED + ) + end + + sig { returns(Integer) } + def scheduled_event_id + end + + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + sig { void } + def clear_scheduled_event_id + end + + sig { returns(Integer) } + def started_event_id + end + + sig { params(value: Integer).void } + def started_event_id=(value) + end + + sig { void } + def clear_started_event_id + end + + sig { returns(String) } + def identity + end + + sig { params(value: String).void } + def identity=(value) + end + + sig { void } + def clear_identity + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::ActivityType)) } + def activity_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ActivityType)).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + sig { returns(T.any(Symbol, Integer)) } + def retry_state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_state=(value) + end + + sig { void } + def clear_retry_state + 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::Failure::V1::ActivityFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ActivityFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::ActivityFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ActivityFailureInfo, 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::Failure::V1::ChildWorkflowExecutionFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + initiated_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + retry_state: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + namespace: "", + workflow_execution: nil, + workflow_type: nil, + initiated_event_id: 0, + started_event_id: 0, + retry_state: :RETRY_STATE_UNSPECIFIED + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(Integer) } + def initiated_event_id + end + + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + sig { void } + def clear_initiated_event_id + end + + sig { returns(Integer) } + def started_event_id + end + + sig { params(value: Integer).void } + def started_event_id=(value) + end + + sig { void } + def clear_started_event_id + end + + sig { returns(T.any(Symbol, Integer)) } + def retry_state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_state=(value) + end + + sig { void } + def clear_retry_state + 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::Failure::V1::ChildWorkflowExecutionFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ChildWorkflowExecutionFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::ChildWorkflowExecutionFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::ChildWorkflowExecutionFailureInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Representation of the Temporal SDK NexusOperationError object that is returned to workflow callers. +class Temporalio::Api::Failure::V1::NexusOperationFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + endpoint: T.nilable(String), + service: T.nilable(String), + operation: T.nilable(String), + operation_id: T.nilable(String), + operation_token: T.nilable(String) + ).void + end + def initialize( + scheduled_event_id: 0, + endpoint: "", + service: "", + operation: "", + operation_id: "", + operation_token: "" + ) + end + + # The NexusOperationScheduled event ID. + sig { returns(Integer) } + def scheduled_event_id + end + + # The NexusOperationScheduled event ID. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The NexusOperationScheduled event ID. + sig { void } + def clear_scheduled_event_id + end + + # Endpoint name. + sig { returns(String) } + def endpoint + end + + # Endpoint name. + sig { params(value: String).void } + def endpoint=(value) + end + + # Endpoint name. + sig { void } + def clear_endpoint + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Operation name. + sig { returns(String) } + def operation + end + + # Operation name. + sig { params(value: String).void } + def operation=(value) + end + + # Operation name. + sig { void } + def clear_operation + end + + # Operation ID - may be empty if the operation completed synchronously. +# +# Deprecated. Renamed to operation_token. + sig { returns(String) } + def operation_id + end + + # Operation ID - may be empty if the operation completed synchronously. +# +# Deprecated. Renamed to operation_token. + sig { params(value: String).void } + def operation_id=(value) + end + + # Operation ID - may be empty if the operation completed synchronously. +# +# Deprecated. Renamed to operation_token. + sig { void } + def clear_operation_id + end + + # Operation token - may be empty if the operation completed synchronously. + sig { returns(String) } + def operation_token + end + + # Operation token - may be empty if the operation completed synchronously. + sig { params(value: String).void } + def operation_token=(value) + end + + # Operation token - may be empty if the operation completed synchronously. + sig { void } + def clear_operation_token + 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::Failure::V1::NexusOperationFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::NexusOperationFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::NexusOperationFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::NexusOperationFailureInfo, 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::Failure::V1::NexusHandlerFailureInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(String), + retry_behavior: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + type: "", + retry_behavior: :NEXUS_HANDLER_ERROR_RETRY_BEHAVIOR_UNSPECIFIED + ) + end + + # The Nexus error type as defined in the spec: +# https://github.com/nexus-rpc/api/blob/main/SPEC.md#predefined-handler-errors. + sig { returns(String) } + def type + end + + # The Nexus error type as defined in the spec: +# https://github.com/nexus-rpc/api/blob/main/SPEC.md#predefined-handler-errors. + sig { params(value: String).void } + def type=(value) + end + + # The Nexus error type as defined in the spec: +# https://github.com/nexus-rpc/api/blob/main/SPEC.md#predefined-handler-errors. + sig { void } + def clear_type + end + + # Retry behavior, defaults to the retry behavior of the error type as defined in the spec. + sig { returns(T.any(Symbol, Integer)) } + def retry_behavior + end + + # Retry behavior, defaults to the retry behavior of the error type as defined in the spec. + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_behavior=(value) + end + + # Retry behavior, defaults to the retry behavior of the error type as defined in the spec. + sig { void } + def clear_retry_behavior + 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::Failure::V1::NexusHandlerFailureInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::NexusHandlerFailureInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::NexusHandlerFailureInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::NexusHandlerFailureInfo, 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::Failure::V1::Failure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + message: T.nilable(String), + source: T.nilable(String), + stack_trace: T.nilable(String), + encoded_attributes: T.nilable(Temporalio::Api::Common::V1::Payload), + cause: T.nilable(Temporalio::Api::Failure::V1::Failure), + application_failure_info: T.nilable(Temporalio::Api::Failure::V1::ApplicationFailureInfo), + timeout_failure_info: T.nilable(Temporalio::Api::Failure::V1::TimeoutFailureInfo), + canceled_failure_info: T.nilable(Temporalio::Api::Failure::V1::CanceledFailureInfo), + terminated_failure_info: T.nilable(Temporalio::Api::Failure::V1::TerminatedFailureInfo), + server_failure_info: T.nilable(Temporalio::Api::Failure::V1::ServerFailureInfo), + reset_workflow_failure_info: T.nilable(Temporalio::Api::Failure::V1::ResetWorkflowFailureInfo), + activity_failure_info: T.nilable(Temporalio::Api::Failure::V1::ActivityFailureInfo), + child_workflow_execution_failure_info: T.nilable(Temporalio::Api::Failure::V1::ChildWorkflowExecutionFailureInfo), + nexus_operation_execution_failure_info: T.nilable(Temporalio::Api::Failure::V1::NexusOperationFailureInfo), + nexus_handler_failure_info: T.nilable(Temporalio::Api::Failure::V1::NexusHandlerFailureInfo) + ).void + end + def initialize( + message: "", + source: "", + stack_trace: "", + encoded_attributes: nil, + cause: nil, + application_failure_info: nil, + timeout_failure_info: nil, + canceled_failure_info: nil, + terminated_failure_info: nil, + server_failure_info: nil, + reset_workflow_failure_info: nil, + activity_failure_info: nil, + child_workflow_execution_failure_info: nil, + nexus_operation_execution_failure_info: nil, + nexus_handler_failure_info: nil + ) + end + + sig { returns(String) } + def message + end + + sig { params(value: String).void } + def message=(value) + end + + sig { void } + def clear_message + end + + # The source this Failure originated in, e.g. TypeScriptSDK / JavaSDK +# In some SDKs this is used to rehydrate the stack trace into an exception object. + sig { returns(String) } + def source + end + + # The source this Failure originated in, e.g. TypeScriptSDK / JavaSDK +# In some SDKs this is used to rehydrate the stack trace into an exception object. + sig { params(value: String).void } + def source=(value) + end + + # The source this Failure originated in, e.g. TypeScriptSDK / JavaSDK +# In some SDKs this is used to rehydrate the stack trace into an exception object. + sig { void } + def clear_source + end + + sig { returns(String) } + def stack_trace + end + + sig { params(value: String).void } + def stack_trace=(value) + end + + sig { void } + def clear_stack_trace + end + + # Alternative way to supply `message` and `stack_trace` and possibly other attributes, used for encryption of +# errors originating in user code which might contain sensitive information. +# The `encoded_attributes` Payload could represent any serializable object, e.g. JSON object or a `Failure` proto +# message. +# +# SDK authors: +# - The SDK should provide a default `encodeFailureAttributes` and `decodeFailureAttributes` implementation that: +# - Uses a JSON object to represent `{ message, stack_trace }`. +# - Overwrites the original message with "Encoded failure" to indicate that more information could be extracted. +# - Overwrites the original stack_trace with an empty string. +# - The resulting JSON object is converted to Payload using the default PayloadConverter and should be processed +# by the user-provided PayloadCodec +# +# - If there's demand, we could allow overriding the default SDK implementation to encode other opaque Failure attributes. +# (-- api-linter: core::0203::optional=disabled --) + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def encoded_attributes + end + + # Alternative way to supply `message` and `stack_trace` and possibly other attributes, used for encryption of +# errors originating in user code which might contain sensitive information. +# The `encoded_attributes` Payload could represent any serializable object, e.g. JSON object or a `Failure` proto +# message. +# +# SDK authors: +# - The SDK should provide a default `encodeFailureAttributes` and `decodeFailureAttributes` implementation that: +# - Uses a JSON object to represent `{ message, stack_trace }`. +# - Overwrites the original message with "Encoded failure" to indicate that more information could be extracted. +# - Overwrites the original stack_trace with an empty string. +# - The resulting JSON object is converted to Payload using the default PayloadConverter and should be processed +# by the user-provided PayloadCodec +# +# - If there's demand, we could allow overriding the default SDK implementation to encode other opaque Failure attributes. +# (-- api-linter: core::0203::optional=disabled --) + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def encoded_attributes=(value) + end + + # Alternative way to supply `message` and `stack_trace` and possibly other attributes, used for encryption of +# errors originating in user code which might contain sensitive information. +# The `encoded_attributes` Payload could represent any serializable object, e.g. JSON object or a `Failure` proto +# message. +# +# SDK authors: +# - The SDK should provide a default `encodeFailureAttributes` and `decodeFailureAttributes` implementation that: +# - Uses a JSON object to represent `{ message, stack_trace }`. +# - Overwrites the original message with "Encoded failure" to indicate that more information could be extracted. +# - Overwrites the original stack_trace with an empty string. +# - The resulting JSON object is converted to Payload using the default PayloadConverter and should be processed +# by the user-provided PayloadCodec +# +# - If there's demand, we could allow overriding the default SDK implementation to encode other opaque Failure attributes. +# (-- api-linter: core::0203::optional=disabled --) + sig { void } + def clear_encoded_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def cause + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def cause=(value) + end + + sig { void } + def clear_cause + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::ApplicationFailureInfo)) } + def application_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::ApplicationFailureInfo)).void } + def application_failure_info=(value) + end + + sig { void } + def clear_application_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::TimeoutFailureInfo)) } + def timeout_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::TimeoutFailureInfo)).void } + def timeout_failure_info=(value) + end + + sig { void } + def clear_timeout_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::CanceledFailureInfo)) } + def canceled_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::CanceledFailureInfo)).void } + def canceled_failure_info=(value) + end + + sig { void } + def clear_canceled_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::TerminatedFailureInfo)) } + def terminated_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::TerminatedFailureInfo)).void } + def terminated_failure_info=(value) + end + + sig { void } + def clear_terminated_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::ServerFailureInfo)) } + def server_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::ServerFailureInfo)).void } + def server_failure_info=(value) + end + + sig { void } + def clear_server_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::ResetWorkflowFailureInfo)) } + def reset_workflow_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::ResetWorkflowFailureInfo)).void } + def reset_workflow_failure_info=(value) + end + + sig { void } + def clear_reset_workflow_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::ActivityFailureInfo)) } + def activity_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::ActivityFailureInfo)).void } + def activity_failure_info=(value) + end + + sig { void } + def clear_activity_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::ChildWorkflowExecutionFailureInfo)) } + def child_workflow_execution_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::ChildWorkflowExecutionFailureInfo)).void } + def child_workflow_execution_failure_info=(value) + end + + sig { void } + def clear_child_workflow_execution_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::NexusOperationFailureInfo)) } + def nexus_operation_execution_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::NexusOperationFailureInfo)).void } + def nexus_operation_execution_failure_info=(value) + end + + sig { void } + def clear_nexus_operation_execution_failure_info + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::NexusHandlerFailureInfo)) } + def nexus_handler_failure_info + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::NexusHandlerFailureInfo)).void } + def nexus_handler_failure_info=(value) + end + + sig { void } + def clear_nexus_handler_failure_info + end + + sig { returns(T.nilable(Symbol)) } + def failure_info + 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::Failure::V1::Failure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::Failure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::Failure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::Failure, 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::Failure::V1::MultiOperationExecutionAborted + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Failure::V1::MultiOperationExecutionAborted) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Failure::V1::MultiOperationExecutionAborted).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Failure::V1::MultiOperationExecutionAborted) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Failure::V1::MultiOperationExecutionAborted, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/filter/v1/message.rbi b/temporalio/rbi/temporalio/api/filter/v1/message.rbi new file mode 100644 index 00000000..7c1dce4d --- /dev/null +++ b/temporalio/rbi/temporalio/api/filter/v1/message.rbi @@ -0,0 +1,267 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/filter/v1/message.proto +# typed: strict + +class Temporalio::Api::Filter::V1::WorkflowExecutionFilter + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + workflow_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Filter::V1::WorkflowExecutionFilter) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Filter::V1::WorkflowExecutionFilter).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Filter::V1::WorkflowExecutionFilter) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Filter::V1::WorkflowExecutionFilter, 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::Filter::V1::WorkflowTypeFilter + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String) + ).void + end + def initialize( + name: "" + ) + end + + sig { returns(String) } + def name + end + + sig { params(value: String).void } + def name=(value) + end + + sig { void } + def clear_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::Filter::V1::WorkflowTypeFilter) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Filter::V1::WorkflowTypeFilter).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Filter::V1::WorkflowTypeFilter) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Filter::V1::WorkflowTypeFilter, 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::Filter::V1::StartTimeFilter + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + earliest_time: T.nilable(Google::Protobuf::Timestamp), + latest_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + earliest_time: nil, + latest_time: nil + ) + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def earliest_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def earliest_time=(value) + end + + sig { void } + def clear_earliest_time + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def latest_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def latest_time=(value) + end + + sig { void } + def clear_latest_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::Filter::V1::StartTimeFilter) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Filter::V1::StartTimeFilter).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Filter::V1::StartTimeFilter) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Filter::V1::StartTimeFilter, 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::Filter::V1::StatusFilter + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + status: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + status: :WORKFLOW_EXECUTION_STATUS_UNSPECIFIED + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def status + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + sig { void } + def clear_status + 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::Filter::V1::StatusFilter) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Filter::V1::StatusFilter).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Filter::V1::StatusFilter) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Filter::V1::StatusFilter, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/history/v1/message.rbi b/temporalio/rbi/temporalio/api/history/v1/message.rbi new file mode 100644 index 00000000..2b336b6c --- /dev/null +++ b/temporalio/rbi/temporalio/api/history/v1/message.rbi @@ -0,0 +1,10581 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/history/v1/message.proto +# typed: strict + +# Always the first event in workflow history +class Temporalio::Api::History::V1::WorkflowExecutionStartedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + parent_workflow_namespace: T.nilable(String), + parent_workflow_namespace_id: T.nilable(String), + parent_workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + parent_initiated_event_id: T.nilable(Integer), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + continued_execution_run_id: T.nilable(String), + initiator: T.nilable(T.any(Symbol, String, Integer)), + continued_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + last_completion_result: T.nilable(Temporalio::Api::Common::V1::Payloads), + original_execution_run_id: T.nilable(String), + identity: T.nilable(String), + first_execution_run_id: T.nilable(String), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + attempt: T.nilable(Integer), + workflow_execution_expiration_time: T.nilable(Google::Protobuf::Timestamp), + cron_schedule: T.nilable(String), + first_workflow_task_backoff: T.nilable(Google::Protobuf::Duration), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + prev_auto_reset_points: T.nilable(Temporalio::Api::Workflow::V1::ResetPoints), + header: T.nilable(Temporalio::Api::Common::V1::Header), + parent_initiated_event_version: T.nilable(Integer), + workflow_id: T.nilable(String), + source_version_stamp: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + completion_callbacks: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Callback)]), + root_workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + inherited_build_id: T.nilable(String), + versioning_override: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride), + parent_pinned_worker_deployment_version: T.nilable(String), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + inherited_pinned_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + inherited_auto_upgrade_info: T.nilable(Temporalio::Api::Deployment::V1::InheritedAutoUpgradeInfo), + eager_execution_accepted: T.nilable(T::Boolean), + declined_target_version_upgrade: T.nilable(Temporalio::Api::History::V1::DeclinedTargetVersionUpgrade), + time_skipping_config: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig), + initial_skipped_duration: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + workflow_type: nil, + parent_workflow_namespace: "", + parent_workflow_namespace_id: "", + parent_workflow_execution: nil, + parent_initiated_event_id: 0, + task_queue: nil, + input: nil, + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + continued_execution_run_id: "", + initiator: :CONTINUE_AS_NEW_INITIATOR_UNSPECIFIED, + continued_failure: nil, + last_completion_result: nil, + original_execution_run_id: "", + identity: "", + first_execution_run_id: "", + retry_policy: nil, + attempt: 0, + workflow_execution_expiration_time: nil, + cron_schedule: "", + first_workflow_task_backoff: nil, + memo: nil, + search_attributes: nil, + prev_auto_reset_points: nil, + header: nil, + parent_initiated_event_version: 0, + workflow_id: "", + source_version_stamp: nil, + completion_callbacks: [], + root_workflow_execution: nil, + inherited_build_id: "", + versioning_override: nil, + parent_pinned_worker_deployment_version: "", + priority: nil, + inherited_pinned_version: nil, + inherited_auto_upgrade_info: nil, + eager_execution_accepted: false, + declined_target_version_upgrade: nil, + time_skipping_config: nil, + initial_skipped_duration: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + # If this workflow is a child, the namespace our parent lives in. +# SDKs and UI tools should use `parent_workflow_namespace` field but server must use `parent_workflow_namespace_id` only. + sig { returns(String) } + def parent_workflow_namespace + end + + # If this workflow is a child, the namespace our parent lives in. +# SDKs and UI tools should use `parent_workflow_namespace` field but server must use `parent_workflow_namespace_id` only. + sig { params(value: String).void } + def parent_workflow_namespace=(value) + end + + # If this workflow is a child, the namespace our parent lives in. +# SDKs and UI tools should use `parent_workflow_namespace` field but server must use `parent_workflow_namespace_id` only. + sig { void } + def clear_parent_workflow_namespace + end + + sig { returns(String) } + def parent_workflow_namespace_id + end + + sig { params(value: String).void } + def parent_workflow_namespace_id=(value) + end + + sig { void } + def clear_parent_workflow_namespace_id + end + + # Contains information about parent workflow execution that initiated the child workflow these attributes belong to. +# If the workflow these attributes belong to is not a child workflow of any other execution, this field will not be populated. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def parent_workflow_execution + end + + # Contains information about parent workflow execution that initiated the child workflow these attributes belong to. +# If the workflow these attributes belong to is not a child workflow of any other execution, this field will not be populated. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def parent_workflow_execution=(value) + end + + # Contains information about parent workflow execution that initiated the child workflow these attributes belong to. +# If the workflow these attributes belong to is not a child workflow of any other execution, this field will not be populated. + sig { void } + def clear_parent_workflow_execution + end + + # EventID of the child execution initiated event in parent workflow + sig { returns(Integer) } + def parent_initiated_event_id + end + + # EventID of the child execution initiated event in parent workflow + sig { params(value: Integer).void } + def parent_initiated_event_id=(value) + end + + # EventID of the child execution initiated event in parent workflow + sig { void } + def clear_parent_initiated_event_id + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + # SDK will deserialize this and provide it as arguments to the workflow function + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # SDK will deserialize this and provide it as arguments to the workflow function + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # SDK will deserialize this and provide it as arguments to the workflow function + sig { void } + def clear_input + end + + # Total workflow execution timeout including retries and continue as new. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + # Total workflow execution timeout including retries and continue as new. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + # Total workflow execution timeout including retries and continue as new. + sig { void } + def clear_workflow_execution_timeout + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # Run id of the previous workflow which continued-as-new or retried or cron executed into this +# workflow. + sig { returns(String) } + def continued_execution_run_id + end + + # Run id of the previous workflow which continued-as-new or retried or cron executed into this +# workflow. + sig { params(value: String).void } + def continued_execution_run_id=(value) + end + + # Run id of the previous workflow which continued-as-new or retried or cron executed into this +# workflow. + sig { void } + def clear_continued_execution_run_id + end + + sig { returns(T.any(Symbol, Integer)) } + def initiator + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def initiator=(value) + end + + sig { void } + def clear_initiator + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def continued_failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def continued_failure=(value) + end + + sig { void } + def clear_continued_failure + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_completion_result + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_completion_result=(value) + end + + sig { void } + def clear_last_completion_result + end + + # This is the run id when the WorkflowExecutionStarted event was written. +# A workflow reset changes the execution run_id, but preserves this field. + sig { returns(String) } + def original_execution_run_id + end + + # This is the run id when the WorkflowExecutionStarted event was written. +# A workflow reset changes the execution run_id, but preserves this field. + sig { params(value: String).void } + def original_execution_run_id=(value) + end + + # This is the run id when the WorkflowExecutionStarted event was written. +# A workflow reset changes the execution run_id, but preserves this field. + sig { void } + def clear_original_execution_run_id + end + + # Identity of the client who requested this execution + sig { returns(String) } + def identity + end + + # Identity of the client who requested this execution + sig { params(value: String).void } + def identity=(value) + end + + # Identity of the client who requested this execution + sig { void } + def clear_identity + end + + # This is the very first runId along the chain of ContinueAsNew, Retry, Cron and Reset. +# Used to identify a chain. + sig { returns(String) } + def first_execution_run_id + end + + # This is the very first runId along the chain of ContinueAsNew, Retry, Cron and Reset. +# Used to identify a chain. + sig { params(value: String).void } + def first_execution_run_id=(value) + end + + # This is the very first runId along the chain of ContinueAsNew, Retry, Cron and Reset. +# Used to identify a chain. + sig { void } + def clear_first_execution_run_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + sig { void } + def clear_retry_policy + end + + # Starting at 1, the number of times we have tried to execute this workflow + sig { returns(Integer) } + def attempt + end + + # Starting at 1, the number of times we have tried to execute this workflow + sig { params(value: Integer).void } + def attempt=(value) + end + + # Starting at 1, the number of times we have tried to execute this workflow + sig { void } + def clear_attempt + end + + # The absolute time at which the workflow will be timed out. +# This is passed without change to the next run/retry of a workflow. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def workflow_execution_expiration_time + end + + # The absolute time at which the workflow will be timed out. +# This is passed without change to the next run/retry of a workflow. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def workflow_execution_expiration_time=(value) + end + + # The absolute time at which the workflow will be timed out. +# This is passed without change to the next run/retry of a workflow. + sig { void } + def clear_workflow_execution_expiration_time + end + + # If this workflow runs on a cron schedule, it will appear here + sig { returns(String) } + def cron_schedule + end + + # If this workflow runs on a cron schedule, it will appear here + sig { params(value: String).void } + def cron_schedule=(value) + end + + # If this workflow runs on a cron schedule, it will appear here + sig { void } + def clear_cron_schedule + end + + # For a cron workflow, this contains the amount of time between when this iteration of +# the cron workflow was scheduled and when it should run next per its cron_schedule. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def first_workflow_task_backoff + end + + # For a cron workflow, this contains the amount of time between when this iteration of +# the cron workflow was scheduled and when it should run next per its cron_schedule. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def first_workflow_task_backoff=(value) + end + + # For a cron workflow, this contains the amount of time between when this iteration of +# the cron workflow was scheduled and when it should run next per its cron_schedule. + sig { void } + def clear_first_workflow_task_backoff + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::ResetPoints)) } + def prev_auto_reset_points + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::ResetPoints)).void } + def prev_auto_reset_points=(value) + end + + sig { void } + def clear_prev_auto_reset_points + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + # Version of the child execution initiated event in parent workflow +# It should be used together with parent_initiated_event_id to identify +# a child initiated event for global namespace + sig { returns(Integer) } + def parent_initiated_event_version + end + + # Version of the child execution initiated event in parent workflow +# It should be used together with parent_initiated_event_id to identify +# a child initiated event for global namespace + sig { params(value: Integer).void } + def parent_initiated_event_version=(value) + end + + # Version of the child execution initiated event in parent workflow +# It should be used together with parent_initiated_event_id to identify +# a child initiated event for global namespace + sig { void } + def clear_parent_initiated_event_version + end + + # This field is new in 1.21. + sig { returns(String) } + def workflow_id + end + + # This field is new in 1.21. + sig { params(value: String).void } + def workflow_id=(value) + end + + # This field is new in 1.21. + sig { void } + def clear_workflow_id + end + + # If this workflow intends to use anything other than the current overall default version for +# the queue, then we include it here. +# Deprecated. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def source_version_stamp + end + + # If this workflow intends to use anything other than the current overall default version for +# the queue, then we include it here. +# Deprecated. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def source_version_stamp=(value) + end + + # If this workflow intends to use anything other than the current overall default version for +# the queue, then we include it here. +# Deprecated. [cleanup-experimental-wv] + sig { void } + def clear_source_version_stamp + end + + # Completion callbacks attached when this workflow was started. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Callback)]) } + def completion_callbacks + end + + # Completion callbacks attached when this workflow was started. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def completion_callbacks=(value) + end + + # Completion callbacks attached when this workflow was started. + sig { void } + def clear_completion_callbacks + end + + # Contains information about the root workflow execution. +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# When the workflow is its own root workflow, then root_workflow_execution is nil. +# Note: workflows continued as new or reseted may or may not have parents, check examples below. +# +# Examples: +# Scenario 1: Workflow W1 starts child workflow W2, and W2 starts child workflow W3. +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 2: Workflow W1 starts child workflow W2, and W2 continued as new W3. +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 3: Workflow W1 continued as new W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# - W1 and W2 have root_workflow_execution set to nil. +# Scenario 4: Workflow W1 starts child workflow W2, and W2 is reseted, creating W3 +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 5: Workflow W1 is reseted, creating W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# - W1 and W2 have root_workflow_execution set to nil. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def root_workflow_execution + end + + # Contains information about the root workflow execution. +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# When the workflow is its own root workflow, then root_workflow_execution is nil. +# Note: workflows continued as new or reseted may or may not have parents, check examples below. +# +# Examples: +# Scenario 1: Workflow W1 starts child workflow W2, and W2 starts child workflow W3. +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 2: Workflow W1 starts child workflow W2, and W2 continued as new W3. +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 3: Workflow W1 continued as new W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# - W1 and W2 have root_workflow_execution set to nil. +# Scenario 4: Workflow W1 starts child workflow W2, and W2 is reseted, creating W3 +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 5: Workflow W1 is reseted, creating W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# - W1 and W2 have root_workflow_execution set to nil. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def root_workflow_execution=(value) + end + + # Contains information about the root workflow execution. +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# When the workflow is its own root workflow, then root_workflow_execution is nil. +# Note: workflows continued as new or reseted may or may not have parents, check examples below. +# +# Examples: +# Scenario 1: Workflow W1 starts child workflow W2, and W2 starts child workflow W3. +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 2: Workflow W1 starts child workflow W2, and W2 continued as new W3. +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 3: Workflow W1 continued as new W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# - W1 and W2 have root_workflow_execution set to nil. +# Scenario 4: Workflow W1 starts child workflow W2, and W2 is reseted, creating W3 +# - The root workflow of all three workflows is W1. +# - W1 has root_workflow_execution set to nil. +# - W2 and W3 have root_workflow_execution set to W1. +# Scenario 5: Workflow W1 is reseted, creating W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# - W1 and W2 have root_workflow_execution set to nil. + sig { void } + def clear_root_workflow_execution + end + + # When present, this execution is assigned to the build ID of its parent or previous execution. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(String) } + def inherited_build_id + end + + # When present, this execution is assigned to the build ID of its parent or previous execution. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: String).void } + def inherited_build_id=(value) + end + + # When present, this execution is assigned to the build ID of its parent or previous execution. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_inherited_build_id + end + + # Versioning override applied to this workflow when it was started. +# Children, crons, retries, and continue-as-new will inherit source run's override if pinned +# and if the new workflow's Task Queue belongs to the override version. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)) } + def versioning_override + end + + # Versioning override applied to this workflow when it was started. +# Children, crons, retries, and continue-as-new will inherit source run's override if pinned +# and if the new workflow's Task Queue belongs to the override version. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)).void } + def versioning_override=(value) + end + + # Versioning override applied to this workflow when it was started. +# Children, crons, retries, and continue-as-new will inherit source run's override if pinned +# and if the new workflow's Task Queue belongs to the override version. + sig { void } + def clear_versioning_override + end + + # When present, it means this is a child workflow of a parent that is Pinned to this Worker +# Deployment Version. In this case, child workflow will start as Pinned to this Version instead +# of starting on the Current Version of its Task Queue. +# This is set only if the child workflow is starting on a Task Queue belonging to the same +# Worker Deployment Version. +# Deprecated. Use `parent_versioning_info`. + sig { returns(String) } + def parent_pinned_worker_deployment_version + end + + # When present, it means this is a child workflow of a parent that is Pinned to this Worker +# Deployment Version. In this case, child workflow will start as Pinned to this Version instead +# of starting on the Current Version of its Task Queue. +# This is set only if the child workflow is starting on a Task Queue belonging to the same +# Worker Deployment Version. +# Deprecated. Use `parent_versioning_info`. + sig { params(value: String).void } + def parent_pinned_worker_deployment_version=(value) + end + + # When present, it means this is a child workflow of a parent that is Pinned to this Worker +# Deployment Version. In this case, child workflow will start as Pinned to this Version instead +# of starting on the Current Version of its Task Queue. +# This is set only if the child workflow is starting on a Task Queue belonging to the same +# Worker Deployment Version. +# Deprecated. Use `parent_versioning_info`. + sig { void } + def clear_parent_pinned_worker_deployment_version + end + + # Priority metadata + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata + sig { void } + def clear_priority + end + + # If present, the new workflow should start on this version with pinned base behavior. +# Child of pinned parent will inherit the parent's version if the Child's Task Queue belongs to that version. +# +# A new run initiated by workflow ContinueAsNew of pinned run, will inherit the previous run's version if the +# new run's Task Queue belongs to that version. +# +# A new run initiated by workflow Cron will never inherit. +# +# A new run initiated by workflow Retry will only inherit if the retried run is effectively pinned at the time +# of retry, and the retried run inherited a pinned version when it started (ie. it is a child of a pinned +# parent, or a CaN of a pinned run, and is running on a Task Queue in the inherited version). +# +# Pinned override is inherited if Task Queue of new run is compatible with the override version. +# Override is inherited separately and takes precedence over inherited base version. +# +# Note: This field is mutually exclusive with inherited_auto_upgrade_info. +# Additionaly, versioning_override, if present, overrides this field during routing decisions. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def inherited_pinned_version + end + + # If present, the new workflow should start on this version with pinned base behavior. +# Child of pinned parent will inherit the parent's version if the Child's Task Queue belongs to that version. +# +# A new run initiated by workflow ContinueAsNew of pinned run, will inherit the previous run's version if the +# new run's Task Queue belongs to that version. +# +# A new run initiated by workflow Cron will never inherit. +# +# A new run initiated by workflow Retry will only inherit if the retried run is effectively pinned at the time +# of retry, and the retried run inherited a pinned version when it started (ie. it is a child of a pinned +# parent, or a CaN of a pinned run, and is running on a Task Queue in the inherited version). +# +# Pinned override is inherited if Task Queue of new run is compatible with the override version. +# Override is inherited separately and takes precedence over inherited base version. +# +# Note: This field is mutually exclusive with inherited_auto_upgrade_info. +# Additionaly, versioning_override, if present, overrides this field during routing decisions. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def inherited_pinned_version=(value) + end + + # If present, the new workflow should start on this version with pinned base behavior. +# Child of pinned parent will inherit the parent's version if the Child's Task Queue belongs to that version. +# +# A new run initiated by workflow ContinueAsNew of pinned run, will inherit the previous run's version if the +# new run's Task Queue belongs to that version. +# +# A new run initiated by workflow Cron will never inherit. +# +# A new run initiated by workflow Retry will only inherit if the retried run is effectively pinned at the time +# of retry, and the retried run inherited a pinned version when it started (ie. it is a child of a pinned +# parent, or a CaN of a pinned run, and is running on a Task Queue in the inherited version). +# +# Pinned override is inherited if Task Queue of new run is compatible with the override version. +# Override is inherited separately and takes precedence over inherited base version. +# +# Note: This field is mutually exclusive with inherited_auto_upgrade_info. +# Additionaly, versioning_override, if present, overrides this field during routing decisions. + sig { void } + def clear_inherited_pinned_version + end + + # If present, the new workflow begins with AutoUpgrade behavior. Before dispatching the +# first workflow task, this field is set to the deployment version on which the parent/ +# previous run was operating. This inheritance only happens when the task queues belong to +# the same deployment version. The first workflow task will then be dispatched to either +# this inherited deployment version, or the current deployment version of the task queue's +# Deployment. After the first workflow task, the effective behavior depends on worker-sent +# values in subsequent workflow tasks. +# +# Inheritance rules: +# - ContinueAsNew and child workflows: inherit AutoUpgrade behavior and deployment version +# - Cron: never inherits +# - Retry: inherits only if the retried run is effectively AutoUpgrade at the time of +# retry, and inherited AutoUpgrade behavior when it started (i.e. it is a child of an +# AutoUpgrade parent or ContinueAsNew of an AutoUpgrade run, running on the same +# deployment as the parent/previous run) +# +# Additional notes: +# - This field is mutually exclusive with `inherited_pinned_version`. +# - `versioning_override`, if present, overrides this field during routing decisions. +# - SDK implementations do not interact with this field and is only used internally by +# the server to ensure task routing correctness. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::InheritedAutoUpgradeInfo)) } + def inherited_auto_upgrade_info + end + + # If present, the new workflow begins with AutoUpgrade behavior. Before dispatching the +# first workflow task, this field is set to the deployment version on which the parent/ +# previous run was operating. This inheritance only happens when the task queues belong to +# the same deployment version. The first workflow task will then be dispatched to either +# this inherited deployment version, or the current deployment version of the task queue's +# Deployment. After the first workflow task, the effective behavior depends on worker-sent +# values in subsequent workflow tasks. +# +# Inheritance rules: +# - ContinueAsNew and child workflows: inherit AutoUpgrade behavior and deployment version +# - Cron: never inherits +# - Retry: inherits only if the retried run is effectively AutoUpgrade at the time of +# retry, and inherited AutoUpgrade behavior when it started (i.e. it is a child of an +# AutoUpgrade parent or ContinueAsNew of an AutoUpgrade run, running on the same +# deployment as the parent/previous run) +# +# Additional notes: +# - This field is mutually exclusive with `inherited_pinned_version`. +# - `versioning_override`, if present, overrides this field during routing decisions. +# - SDK implementations do not interact with this field and is only used internally by +# the server to ensure task routing correctness. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::InheritedAutoUpgradeInfo)).void } + def inherited_auto_upgrade_info=(value) + end + + # If present, the new workflow begins with AutoUpgrade behavior. Before dispatching the +# first workflow task, this field is set to the deployment version on which the parent/ +# previous run was operating. This inheritance only happens when the task queues belong to +# the same deployment version. The first workflow task will then be dispatched to either +# this inherited deployment version, or the current deployment version of the task queue's +# Deployment. After the first workflow task, the effective behavior depends on worker-sent +# values in subsequent workflow tasks. +# +# Inheritance rules: +# - ContinueAsNew and child workflows: inherit AutoUpgrade behavior and deployment version +# - Cron: never inherits +# - Retry: inherits only if the retried run is effectively AutoUpgrade at the time of +# retry, and inherited AutoUpgrade behavior when it started (i.e. it is a child of an +# AutoUpgrade parent or ContinueAsNew of an AutoUpgrade run, running on the same +# deployment as the parent/previous run) +# +# Additional notes: +# - This field is mutually exclusive with `inherited_pinned_version`. +# - `versioning_override`, if present, overrides this field during routing decisions. +# - SDK implementations do not interact with this field and is only used internally by +# the server to ensure task routing correctness. + sig { void } + def clear_inherited_auto_upgrade_info + end + + # A boolean indicating whether the SDK has asked to eagerly execute the first workflow task for this workflow and +# eager execution was accepted by the server. +# Only populated by server with version >= 1.29.0. + sig { returns(T::Boolean) } + def eager_execution_accepted + end + + # A boolean indicating whether the SDK has asked to eagerly execute the first workflow task for this workflow and +# eager execution was accepted by the server. +# Only populated by server with version >= 1.29.0. + sig { params(value: T::Boolean).void } + def eager_execution_accepted=(value) + end + + # A boolean indicating whether the SDK has asked to eagerly execute the first workflow task for this workflow and +# eager execution was accepted by the server. +# Only populated by server with version >= 1.29.0. + sig { void } + def clear_eager_execution_accepted + end + + # During a previous run of this workflow, the server may have notified the SDK +# that the Target Worker Deployment Version changed, but the SDK declined to +# upgrade (e.g., by continuing-as-new with PINNED behavior). This field records +# the target version that was declined. +# +# This is a wrapper message to distinguish "never declined" (nil wrapper) from +# "declined an unversioned target" (non-nil wrapper with nil deployment_version). +# +# Used internally by the server during continue-as-new and retry. +# Should not be read or interpreted by SDKs. + sig { returns(T.nilable(Temporalio::Api::History::V1::DeclinedTargetVersionUpgrade)) } + def declined_target_version_upgrade + end + + # During a previous run of this workflow, the server may have notified the SDK +# that the Target Worker Deployment Version changed, but the SDK declined to +# upgrade (e.g., by continuing-as-new with PINNED behavior). This field records +# the target version that was declined. +# +# This is a wrapper message to distinguish "never declined" (nil wrapper) from +# "declined an unversioned target" (non-nil wrapper with nil deployment_version). +# +# Used internally by the server during continue-as-new and retry. +# Should not be read or interpreted by SDKs. + sig { params(value: T.nilable(Temporalio::Api::History::V1::DeclinedTargetVersionUpgrade)).void } + def declined_target_version_upgrade=(value) + end + + # During a previous run of this workflow, the server may have notified the SDK +# that the Target Worker Deployment Version changed, but the SDK declined to +# upgrade (e.g., by continuing-as-new with PINNED behavior). This field records +# the target version that was declined. +# +# This is a wrapper message to distinguish "never declined" (nil wrapper) from +# "declined an unversioned target" (non-nil wrapper with nil deployment_version). +# +# Used internally by the server during continue-as-new and retry. +# Should not be read or interpreted by SDKs. + sig { void } + def clear_declined_target_version_upgrade + end + + # Initial time-skipping configuration for this workflow execution, recorded at start time. +# This may have been set explicitly via the start workflow request, or propagated from a +# parent/previous execution. +# +# The configuration may be updated after start via UpdateWorkflowExecutionOptions, which +# will be reflected in the WorkflowExecutionOptionsUpdatedEvent. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)) } + def time_skipping_config + end + + # Initial time-skipping configuration for this workflow execution, recorded at start time. +# This may have been set explicitly via the start workflow request, or propagated from a +# parent/previous execution. +# +# The configuration may be updated after start via UpdateWorkflowExecutionOptions, which +# will be reflected in the WorkflowExecutionOptionsUpdatedEvent. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)).void } + def time_skipping_config=(value) + end + + # Initial time-skipping configuration for this workflow execution, recorded at start time. +# This may have been set explicitly via the start workflow request, or propagated from a +# parent/previous execution. +# +# The configuration may be updated after start via UpdateWorkflowExecutionOptions, which +# will be reflected in the WorkflowExecutionOptionsUpdatedEvent. + sig { void } + def clear_time_skipping_config + end + + # The time skipped by the previous execution that started this workflow. +# It can happen in cases of child workflows and continue-as-new workflows. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def initial_skipped_duration + end + + # The time skipped by the previous execution that started this workflow. +# It can happen in cases of child workflows and continue-as-new workflows. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def initial_skipped_duration=(value) + end + + # The time skipped by the previous execution that started this workflow. +# It can happen in cases of child workflows and continue-as-new workflows. + sig { void } + def clear_initial_skipped_duration + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::History::V1::WorkflowExecutionStartedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionStartedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionStartedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionStartedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Wrapper for a target deployment version that the SDK declined to upgrade to. +# See declined_target_version_upgrade on WorkflowExecutionStartedEventAttributes. +class Temporalio::Api::History::V1::DeclinedTargetVersionUpgrade + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + revision_number: T.nilable(Integer) + ).void + end + def initialize( + deployment_version: nil, + revision_number: 0 + ) + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + sig { void } + def clear_deployment_version + end + + # Revision number of the task queue routing config at the time the target +# was declined. If an incoming target's revision is <= this value, it is +# not newer and is not used for deciding whether or not to suppress the +# upgrade signal. + sig { returns(Integer) } + def revision_number + end + + # Revision number of the task queue routing config at the time the target +# was declined. If an incoming target's revision is <= this value, it is +# not newer and is not used for deciding whether or not to suppress the +# upgrade signal. + sig { params(value: Integer).void } + def revision_number=(value) + end + + # Revision number of the task queue routing config at the time the target +# was declined. If an incoming target's revision is <= this value, it is +# not newer and is not used for deciding whether or not to suppress the +# upgrade signal. + sig { void } + def clear_revision_number + 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::History::V1::DeclinedTargetVersionUpgrade) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::DeclinedTargetVersionUpgrade).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::DeclinedTargetVersionUpgrade) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::DeclinedTargetVersionUpgrade, 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::History::V1::WorkflowExecutionCompletedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_task_completed_event_id: T.nilable(Integer), + new_execution_run_id: T.nilable(String) + ).void + end + def initialize( + result: nil, + workflow_task_completed_event_id: 0, + new_execution_run_id: "" + ) + end + + # Serialized result of workflow completion (ie: The return value of the workflow function) + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def result + end + + # Serialized result of workflow completion (ie: The return value of the workflow function) + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def result=(value) + end + + # Serialized result of workflow completion (ie: The return value of the workflow function) + sig { void } + def clear_result + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # If another run is started by cron, this contains the new run id. + sig { returns(String) } + def new_execution_run_id + end + + # If another run is started by cron, this contains the new run id. + sig { params(value: String).void } + def new_execution_run_id=(value) + end + + # If another run is started by cron, this contains the new run id. + sig { void } + def clear_new_execution_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::History::V1::WorkflowExecutionCompletedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionCompletedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionCompletedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionCompletedEventAttributes, 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::History::V1::WorkflowExecutionFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + retry_state: T.nilable(T.any(Symbol, String, Integer)), + workflow_task_completed_event_id: T.nilable(Integer), + new_execution_run_id: T.nilable(String) + ).void + end + def initialize( + failure: nil, + retry_state: :RETRY_STATE_UNSPECIFIED, + workflow_task_completed_event_id: 0, + new_execution_run_id: "" + ) + end + + # Serialized result of workflow failure (ex: An exception thrown, or error returned) + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Serialized result of workflow failure (ex: An exception thrown, or error returned) + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Serialized result of workflow failure (ex: An exception thrown, or error returned) + sig { void } + def clear_failure + end + + sig { returns(T.any(Symbol, Integer)) } + def retry_state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_state=(value) + end + + sig { void } + def clear_retry_state + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # If another run is started by cron or retry, this contains the new run id. + sig { returns(String) } + def new_execution_run_id + end + + # If another run is started by cron or retry, this contains the new run id. + sig { params(value: String).void } + def new_execution_run_id=(value) + end + + # If another run is started by cron or retry, this contains the new run id. + sig { void } + def clear_new_execution_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::History::V1::WorkflowExecutionFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionFailedEventAttributes, 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::History::V1::WorkflowExecutionTimedOutEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + retry_state: T.nilable(T.any(Symbol, String, Integer)), + new_execution_run_id: T.nilable(String) + ).void + end + def initialize( + retry_state: :RETRY_STATE_UNSPECIFIED, + new_execution_run_id: "" + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def retry_state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_state=(value) + end + + sig { void } + def clear_retry_state + end + + # If another run is started by cron or retry, this contains the new run id. + sig { returns(String) } + def new_execution_run_id + end + + # If another run is started by cron or retry, this contains the new run id. + sig { params(value: String).void } + def new_execution_run_id=(value) + end + + # If another run is started by cron or retry, this contains the new run id. + sig { void } + def clear_new_execution_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::History::V1::WorkflowExecutionTimedOutEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionTimedOutEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionTimedOutEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionTimedOutEventAttributes, 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::History::V1::WorkflowExecutionContinuedAsNewEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + new_execution_run_id: T.nilable(String), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_completed_event_id: T.nilable(Integer), + backoff_start_interval: T.nilable(Google::Protobuf::Duration), + initiator: T.nilable(T.any(Symbol, String, Integer)), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + last_completion_result: T.nilable(Temporalio::Api::Common::V1::Payloads), + header: T.nilable(Temporalio::Api::Common::V1::Header), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + inherit_build_id: T.nilable(T::Boolean), + initial_versioning_behavior: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + new_execution_run_id: "", + workflow_type: nil, + task_queue: nil, + input: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + workflow_task_completed_event_id: 0, + backoff_start_interval: nil, + initiator: :CONTINUE_AS_NEW_INITIATOR_UNSPECIFIED, + failure: nil, + last_completion_result: nil, + header: nil, + memo: nil, + search_attributes: nil, + inherit_build_id: false, + initial_versioning_behavior: :CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_UNSPECIFIED + ) + end + + # The run ID of the new workflow started by this continue-as-new + sig { returns(String) } + def new_execution_run_id + end + + # The run ID of the new workflow started by this continue-as-new + sig { params(value: String).void } + def new_execution_run_id=(value) + end + + # The run ID of the new workflow started by this continue-as-new + sig { void } + def clear_new_execution_run_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + sig { void } + def clear_input + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # How long the server will wait before scheduling the first workflow task for the new run. +# Used for cron, retry, and other continue-as-new cases that server may enforce some minimal +# delay between new runs for system protection purpose. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def backoff_start_interval + end + + # How long the server will wait before scheduling the first workflow task for the new run. +# Used for cron, retry, and other continue-as-new cases that server may enforce some minimal +# delay between new runs for system protection purpose. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def backoff_start_interval=(value) + end + + # How long the server will wait before scheduling the first workflow task for the new run. +# Used for cron, retry, and other continue-as-new cases that server may enforce some minimal +# delay between new runs for system protection purpose. + sig { void } + def clear_backoff_start_interval + end + + sig { returns(T.any(Symbol, Integer)) } + def initiator + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def initiator=(value) + end + + sig { void } + def clear_initiator + end + + # Deprecated. If a workflow's retry policy would cause a new run to start when the current one +# has failed, this field would be populated with that failure. Now (when supported by server +# and sdk) the final event will be `WORKFLOW_EXECUTION_FAILED` with `new_execution_run_id` set. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Deprecated. If a workflow's retry policy would cause a new run to start when the current one +# has failed, this field would be populated with that failure. Now (when supported by server +# and sdk) the final event will be `WORKFLOW_EXECUTION_FAILED` with `new_execution_run_id` set. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Deprecated. If a workflow's retry policy would cause a new run to start when the current one +# has failed, this field would be populated with that failure. Now (when supported by server +# and sdk) the final event will be `WORKFLOW_EXECUTION_FAILED` with `new_execution_run_id` set. + sig { void } + def clear_failure + end + + # The result from the most recent completed run of this workflow. The SDK surfaces this to the +# new run via APIs such as `GetLastCompletionResult`. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_completion_result + end + + # The result from the most recent completed run of this workflow. The SDK surfaces this to the +# new run via APIs such as `GetLastCompletionResult`. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_completion_result=(value) + end + + # The result from the most recent completed run of this workflow. The SDK surfaces this to the +# new run via APIs such as `GetLastCompletionResult`. + sig { void } + def clear_last_completion_result + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + # If this is set, the new execution inherits the Build ID of the current execution. Otherwise, +# the assignment rules will be used to independently assign a Build ID to the new execution. +# Deprecated. Only considered for versioning v0.2. + sig { returns(T::Boolean) } + def inherit_build_id + end + + # If this is set, the new execution inherits the Build ID of the current execution. Otherwise, +# the assignment rules will be used to independently assign a Build ID to the new execution. +# Deprecated. Only considered for versioning v0.2. + sig { params(value: T::Boolean).void } + def inherit_build_id=(value) + end + + # If this is set, the new execution inherits the Build ID of the current execution. Otherwise, +# the assignment rules will be used to independently assign a Build ID to the new execution. +# Deprecated. Only considered for versioning v0.2. + sig { void } + def clear_inherit_build_id + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { returns(T.any(Symbol, Integer)) } + def initial_versioning_behavior + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { params(value: T.any(Symbol, String, Integer)).void } + def initial_versioning_behavior=(value) + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { void } + def clear_initial_versioning_behavior + 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::History::V1::WorkflowExecutionContinuedAsNewEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionContinuedAsNewEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionContinuedAsNewEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionContinuedAsNewEventAttributes, 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::History::V1::WorkflowTaskScheduledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + attempt: T.nilable(Integer) + ).void + end + def initialize( + task_queue: nil, + start_to_close_timeout: nil, + attempt: 0 + ) + end + + # The task queue this workflow task was enqueued in, which could be a normal or sticky queue + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + # The task queue this workflow task was enqueued in, which could be a normal or sticky queue + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + # The task queue this workflow task was enqueued in, which could be a normal or sticky queue + sig { void } + def clear_task_queue + end + + # How long the worker has to process this task once receiving it before it times out +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # How long the worker has to process this task once receiving it before it times out +# +# (-- 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 start_to_close_timeout=(value) + end + + # How long the worker has to process this task once receiving it before it times out +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # Starting at 1, how many attempts there have been to complete this task + sig { returns(Integer) } + def attempt + end + + # Starting at 1, how many attempts there have been to complete this task + sig { params(value: Integer).void } + def attempt=(value) + end + + # Starting at 1, how many attempts there have been to complete this task + sig { void } + def clear_attempt + 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::History::V1::WorkflowTaskScheduledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskScheduledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowTaskScheduledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskScheduledEventAttributes, 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::History::V1::WorkflowTaskStartedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + identity: T.nilable(String), + request_id: T.nilable(String), + suggest_continue_as_new: T.nilable(T::Boolean), + suggest_continue_as_new_reasons: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + target_worker_deployment_version_changed: T.nilable(T::Boolean), + history_size_bytes: T.nilable(Integer), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + build_id_redirect_counter: T.nilable(Integer) + ).void + end + def initialize( + scheduled_event_id: 0, + identity: "", + request_id: "", + suggest_continue_as_new: false, + suggest_continue_as_new_reasons: [], + target_worker_deployment_version_changed: false, + history_size_bytes: 0, + worker_version: nil, + build_id_redirect_counter: 0 + ) + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { void } + def clear_scheduled_event_id + end + + # Identity of the worker who picked up this task + sig { returns(String) } + def identity + end + + # Identity of the worker who picked up this task + sig { params(value: String).void } + def identity=(value) + end + + # Identity of the worker who picked up this task + sig { void } + def clear_identity + end + + # This field is populated from the RecordWorkflowTaskStartedRequest. Matching service would +# set the request_id on the RecordWorkflowTaskStartedRequest to a new UUID. This is useful +# in case a RecordWorkflowTaskStarted call succeed but matching doesn't get that response, +# so matching could retry and history service would return success if the request_id matches. +# In that case, matching will continue to deliver the task to worker. Without this field, history +# service would return AlreadyStarted error, and matching would drop the task. + sig { returns(String) } + def request_id + end + + # This field is populated from the RecordWorkflowTaskStartedRequest. Matching service would +# set the request_id on the RecordWorkflowTaskStartedRequest to a new UUID. This is useful +# in case a RecordWorkflowTaskStarted call succeed but matching doesn't get that response, +# so matching could retry and history service would return success if the request_id matches. +# In that case, matching will continue to deliver the task to worker. Without this field, history +# service would return AlreadyStarted error, and matching would drop the task. + sig { params(value: String).void } + def request_id=(value) + end + + # This field is populated from the RecordWorkflowTaskStartedRequest. Matching service would +# set the request_id on the RecordWorkflowTaskStartedRequest to a new UUID. This is useful +# in case a RecordWorkflowTaskStarted call succeed but matching doesn't get that response, +# so matching could retry and history service would return success if the request_id matches. +# In that case, matching will continue to deliver the task to worker. Without this field, history +# service would return AlreadyStarted error, and matching would drop the task. + sig { void } + def clear_request_id + end + + # True if this workflow should continue-as-new soon. See `suggest_continue_as_new_reasons` for why. + sig { returns(T::Boolean) } + def suggest_continue_as_new + end + + # True if this workflow should continue-as-new soon. See `suggest_continue_as_new_reasons` for why. + sig { params(value: T::Boolean).void } + def suggest_continue_as_new=(value) + end + + # True if this workflow should continue-as-new soon. See `suggest_continue_as_new_reasons` for why. + sig { void } + def clear_suggest_continue_as_new + end + + # The reason(s) that suggest_continue_as_new is true, if it is. +# Unset if suggest_continue_as_new is false. + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def suggest_continue_as_new_reasons + end + + # The reason(s) that suggest_continue_as_new is true, if it is. +# Unset if suggest_continue_as_new is false. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def suggest_continue_as_new_reasons=(value) + end + + # The reason(s) that suggest_continue_as_new is true, if it is. +# Unset if suggest_continue_as_new is false. + sig { void } + def clear_suggest_continue_as_new_reasons + end + + # True if Workflow's Target Worker Deployment Version is different from its Pinned Version and +# the workflow is Pinned. +# Experimental. + sig { returns(T::Boolean) } + def target_worker_deployment_version_changed + end + + # True if Workflow's Target Worker Deployment Version is different from its Pinned Version and +# the workflow is Pinned. +# Experimental. + sig { params(value: T::Boolean).void } + def target_worker_deployment_version_changed=(value) + end + + # True if Workflow's Target Worker Deployment Version is different from its Pinned Version and +# the workflow is Pinned. +# Experimental. + sig { void } + def clear_target_worker_deployment_version_changed + end + + # Total history size in bytes, which the workflow might use to decide when to +# continue-as-new regardless of the suggestion. Note that history event count is +# just the event id of this event, so we don't include it explicitly here. + sig { returns(Integer) } + def history_size_bytes + end + + # Total history size in bytes, which the workflow might use to decide when to +# continue-as-new regardless of the suggestion. Note that history event count is +# just the event id of this event, so we don't include it explicitly here. + sig { params(value: Integer).void } + def history_size_bytes=(value) + end + + # Total history size in bytes, which the workflow might use to decide when to +# continue-as-new regardless of the suggestion. Note that history event count is +# just the event id of this event, so we don't include it explicitly here. + sig { void } + def clear_history_size_bytes + end + + # Version info of the worker to whom this task was dispatched. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker to whom this task was dispatched. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker to whom this task was dispatched. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_worker_version + end + + # Used by server internally to properly reapply build ID redirects to an execution +# when rebuilding it from events. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(Integer) } + def build_id_redirect_counter + end + + # Used by server internally to properly reapply build ID redirects to an execution +# when rebuilding it from events. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: Integer).void } + def build_id_redirect_counter=(value) + end + + # Used by server internally to properly reapply build ID redirects to an execution +# when rebuilding it from events. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_build_id_redirect_counter + 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::History::V1::WorkflowTaskStartedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskStartedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowTaskStartedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskStartedEventAttributes, 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::History::V1::WorkflowTaskCompletedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + identity: T.nilable(String), + binary_checksum: T.nilable(String), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + sdk_metadata: T.nilable(Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata), + metering_metadata: T.nilable(Temporalio::Api::Common::V1::MeteringMetadata), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + versioning_behavior: T.nilable(T.any(Symbol, String, Integer)), + worker_deployment_version: T.nilable(String), + worker_deployment_name: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion) + ).void + end + def initialize( + scheduled_event_id: 0, + started_event_id: 0, + identity: "", + binary_checksum: "", + worker_version: nil, + sdk_metadata: nil, + metering_metadata: nil, + deployment: nil, + versioning_behavior: :VERSIONING_BEHAVIOR_UNSPECIFIED, + worker_deployment_version: "", + worker_deployment_name: "", + deployment_version: nil + ) + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { void } + def clear_scheduled_event_id + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { returns(Integer) } + def started_event_id + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { void } + def clear_started_event_id + end + + # Identity of the worker who completed this task + sig { returns(String) } + def identity + end + + # Identity of the worker who completed this task + sig { params(value: String).void } + def identity=(value) + end + + # Identity of the worker who completed this task + sig { void } + def clear_identity + end + + # Binary ID of the worker who completed this task +# Deprecated. Replaced with `deployment_version`. + sig { returns(String) } + def binary_checksum + end + + # Binary ID of the worker who completed this task +# Deprecated. Replaced with `deployment_version`. + sig { params(value: String).void } + def binary_checksum=(value) + end + + # Binary ID of the worker who completed this task +# Deprecated. Replaced with `deployment_version`. + sig { void } + def clear_binary_checksum + end + + # Version info of the worker who processed this workflow task. If present, the `build_id` field +# within is also used as `binary_checksum`, which may be omitted in that case (it may also be +# populated to preserve compatibility). +# Deprecated. Use `deployment_version` and `versioning_behavior` instead. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this workflow task. If present, the `build_id` field +# within is also used as `binary_checksum`, which may be omitted in that case (it may also be +# populated to preserve compatibility). +# Deprecated. Use `deployment_version` and `versioning_behavior` instead. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this workflow task. If present, the `build_id` field +# within is also used as `binary_checksum`, which may be omitted in that case (it may also be +# populated to preserve compatibility). +# Deprecated. Use `deployment_version` and `versioning_behavior` instead. + sig { void } + def clear_worker_version + end + + # Data the SDK wishes to record for itself, but server need not interpret, and does not +# directly impact workflow state. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata)) } + def sdk_metadata + end + + # Data the SDK wishes to record for itself, but server need not interpret, and does not +# directly impact workflow state. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata)).void } + def sdk_metadata=(value) + end + + # Data the SDK wishes to record for itself, but server need not interpret, and does not +# directly impact workflow state. + sig { void } + def clear_sdk_metadata + end + + # Local usage data sent during workflow task completion and recorded here for posterity + sig { returns(T.nilable(Temporalio::Api::Common::V1::MeteringMetadata)) } + def metering_metadata + end + + # Local usage data sent during workflow task completion and recorded here for posterity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::MeteringMetadata)).void } + def metering_metadata=(value) + end + + # Local usage data sent during workflow task completion and recorded here for posterity + sig { void } + def clear_metering_metadata + end + + # The deployment that completed this task. May or may not be set for unversioned workers, +# depending on whether a value is sent by the SDK. This value updates workflow execution's +# `versioning_info.deployment`. +# Deprecated. Replaced with `deployment_version`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # The deployment that completed this task. May or may not be set for unversioned workers, +# depending on whether a value is sent by the SDK. This value updates workflow execution's +# `versioning_info.deployment`. +# Deprecated. Replaced with `deployment_version`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # The deployment that completed this task. May or may not be set for unversioned workers, +# depending on whether a value is sent by the SDK. This value updates workflow execution's +# `versioning_info.deployment`. +# Deprecated. Replaced with `deployment_version`. + sig { void } + def clear_deployment + end + + # Versioning behavior sent by the worker that completed this task for this particular workflow +# execution. UNSPECIFIED means the task was completed by an unversioned worker. This value +# updates workflow execution's `versioning_info.behavior`. + sig { returns(T.any(Symbol, Integer)) } + def versioning_behavior + end + + # Versioning behavior sent by the worker that completed this task for this particular workflow +# execution. UNSPECIFIED means the task was completed by an unversioned worker. This value +# updates workflow execution's `versioning_info.behavior`. + sig { params(value: T.any(Symbol, String, Integer)).void } + def versioning_behavior=(value) + end + + # Versioning behavior sent by the worker that completed this task for this particular workflow +# execution. UNSPECIFIED means the task was completed by an unversioned worker. This value +# updates workflow execution's `versioning_info.behavior`. + sig { void } + def clear_versioning_behavior + end + + # The Worker Deployment Version that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `versioning_info.version`. +# Deprecated. Replaced with `deployment_version`. + sig { returns(String) } + def worker_deployment_version + end + + # The Worker Deployment Version that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `versioning_info.version`. +# Deprecated. Replaced with `deployment_version`. + sig { params(value: String).void } + def worker_deployment_version=(value) + end + + # The Worker Deployment Version that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `versioning_info.version`. +# Deprecated. Replaced with `deployment_version`. + sig { void } + def clear_worker_deployment_version + end + + # The name of Worker Deployment that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `worker_deployment_name`. + sig { returns(String) } + def worker_deployment_name + end + + # The name of Worker Deployment that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `worker_deployment_name`. + sig { params(value: String).void } + def worker_deployment_name=(value) + end + + # The name of Worker Deployment that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `worker_deployment_name`. + sig { void } + def clear_worker_deployment_name + end + + # The Worker Deployment Version that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `versioning_info.deployment_version`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # The Worker Deployment Version that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `versioning_info.deployment_version`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # The Worker Deployment Version that completed this task. Must be set if `versioning_behavior` +# is set. This value updates workflow execution's `versioning_info.deployment_version`. + sig { void } + def clear_deployment_version + 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::History::V1::WorkflowTaskCompletedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskCompletedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowTaskCompletedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskCompletedEventAttributes, 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::History::V1::WorkflowTaskTimedOutEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + timeout_type: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + scheduled_event_id: 0, + started_event_id: 0, + timeout_type: :TIMEOUT_TYPE_UNSPECIFIED + ) + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { void } + def clear_scheduled_event_id + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { returns(Integer) } + def started_event_id + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { void } + def clear_started_event_id + end + + sig { returns(T.any(Symbol, Integer)) } + def timeout_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def timeout_type=(value) + end + + sig { void } + def clear_timeout_type + 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::History::V1::WorkflowTaskTimedOutEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskTimedOutEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowTaskTimedOutEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskTimedOutEventAttributes, 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::History::V1::WorkflowTaskFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + cause: T.nilable(T.any(Symbol, String, Integer)), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + identity: T.nilable(String), + base_run_id: T.nilable(String), + new_run_id: T.nilable(String), + fork_event_version: T.nilable(Integer), + binary_checksum: T.nilable(String), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp) + ).void + end + def initialize( + scheduled_event_id: 0, + started_event_id: 0, + cause: :WORKFLOW_TASK_FAILED_CAUSE_UNSPECIFIED, + failure: nil, + identity: "", + base_run_id: "", + new_run_id: "", + fork_event_version: 0, + binary_checksum: "", + worker_version: nil + ) + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `WORKFLOW_TASK_SCHEDULED` event this task corresponds to + sig { void } + def clear_scheduled_event_id + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { returns(Integer) } + def started_event_id + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `WORKFLOW_TASK_STARTED` event this task corresponds to + sig { void } + def clear_started_event_id + end + + sig { returns(T.any(Symbol, Integer)) } + def cause + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def cause=(value) + end + + sig { void } + def clear_cause + end + + # The failure details + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The failure details + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The failure details + sig { void } + def clear_failure + end + + # If a worker explicitly failed this task, this field contains the worker's identity. +# When the server generates the failure internally this field is set as 'history-service'. + sig { returns(String) } + def identity + end + + # If a worker explicitly failed this task, this field contains the worker's identity. +# When the server generates the failure internally this field is set as 'history-service'. + sig { params(value: String).void } + def identity=(value) + end + + # If a worker explicitly failed this task, this field contains the worker's identity. +# When the server generates the failure internally this field is set as 'history-service'. + sig { void } + def clear_identity + end + + # The original run id of the workflow. For reset workflow. + sig { returns(String) } + def base_run_id + end + + # The original run id of the workflow. For reset workflow. + sig { params(value: String).void } + def base_run_id=(value) + end + + # The original run id of the workflow. For reset workflow. + sig { void } + def clear_base_run_id + end + + # If the workflow is being reset, the new run id. + sig { returns(String) } + def new_run_id + end + + # If the workflow is being reset, the new run id. + sig { params(value: String).void } + def new_run_id=(value) + end + + # If the workflow is being reset, the new run id. + sig { void } + def clear_new_run_id + end + + # Version of the event where the history branch was forked. Used by multi-cluster replication +# during resets to identify the correct history branch. + sig { returns(Integer) } + def fork_event_version + end + + # Version of the event where the history branch was forked. Used by multi-cluster replication +# during resets to identify the correct history branch. + sig { params(value: Integer).void } + def fork_event_version=(value) + end + + # Version of the event where the history branch was forked. Used by multi-cluster replication +# during resets to identify the correct history branch. + sig { void } + def clear_fork_event_version + end + + # Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] +# If a worker explicitly failed this task, its binary id + sig { returns(String) } + def binary_checksum + end + + # Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] +# If a worker explicitly failed this task, its binary id + sig { params(value: String).void } + def binary_checksum=(value) + end + + # Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] +# If a worker explicitly failed this task, its binary id + sig { void } + def clear_binary_checksum + end + + # Version info of the worker who processed this workflow task. If present, the `build_id` field +# within is also used as `binary_checksum`, which may be omitted in that case (it may also be +# populated to preserve compatibility). +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this workflow task. If present, the `build_id` field +# within is also used as `binary_checksum`, which may be omitted in that case (it may also be +# populated to preserve compatibility). +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this workflow task. If present, the `build_id` field +# within is also used as `binary_checksum`, which may be omitted in that case (it may also be +# populated to preserve compatibility). +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_worker_version + 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::History::V1::WorkflowTaskFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowTaskFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowTaskFailedEventAttributes, 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::History::V1::ActivityTaskScheduledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_id: T.nilable(String), + activity_type: T.nilable(Temporalio::Api::Common::V1::ActivityType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + header: T.nilable(Temporalio::Api::Common::V1::Header), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + heartbeat_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_completed_event_id: T.nilable(Integer), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + use_workflow_build_id: T.nilable(T::Boolean), + priority: T.nilable(Temporalio::Api::Common::V1::Priority) + ).void + end + def initialize( + activity_id: "", + activity_type: nil, + task_queue: nil, + header: nil, + input: nil, + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + heartbeat_timeout: nil, + workflow_task_completed_event_id: 0, + retry_policy: nil, + use_workflow_build_id: false, + priority: nil + ) + end + + # The worker/user assigned identifier for the activity + sig { returns(String) } + def activity_id + end + + # The worker/user assigned identifier for the activity + sig { params(value: String).void } + def activity_id=(value) + end + + # The worker/user assigned identifier for the activity + sig { void } + def clear_activity_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::ActivityType)) } + def activity_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ActivityType)).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + sig { void } + def clear_input + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- 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_close_timeout + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- 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_close_timeout=(value) + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` or workflow execution timeout if not +# specified. +# +# (-- 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 + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` or workflow execution timeout if not +# specified. +# +# (-- 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 + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` or workflow execution timeout if not +# specified. +# +# (-- 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 + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- 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 start_to_close_timeout=(value) + end + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def heartbeat_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def heartbeat_timeout=(value) + end + + # Maximum permitted time between successful worker heartbeats. + sig { void } + def clear_heartbeat_timeout + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # Activities are assigned a default retry policy controlled by the service's dynamic +# configuration. Retries will happen up to `schedule_to_close_timeout`. To disable retries set +# retry_policy.maximum_attempts to 1. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # Activities are assigned a default retry policy controlled by the service's dynamic +# configuration. Retries will happen up to `schedule_to_close_timeout`. To disable retries set +# retry_policy.maximum_attempts to 1. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # Activities are assigned a default retry policy controlled by the service's dynamic +# configuration. Retries will happen up to `schedule_to_close_timeout`. To disable retries set +# retry_policy.maximum_attempts to 1. + sig { void } + def clear_retry_policy + end + + # If this is set, the activity would be assigned to the Build ID of the workflow. Otherwise, +# Assignment rules of the activity's Task Queue will be used to determine the Build ID. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T::Boolean) } + def use_workflow_build_id + end + + # If this is set, the activity would be assigned to the Build ID of the workflow. Otherwise, +# Assignment rules of the activity's Task Queue will be used to determine the Build ID. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T::Boolean).void } + def use_workflow_build_id=(value) + end + + # If this is set, the activity would be assigned to the Build ID of the workflow. Otherwise, +# Assignment rules of the activity's Task Queue will be used to determine the Build ID. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_use_workflow_build_id + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { void } + def clear_priority + 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::History::V1::ActivityTaskScheduledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskScheduledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ActivityTaskScheduledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskScheduledEventAttributes, 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::History::V1::ActivityTaskStartedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + identity: T.nilable(String), + request_id: T.nilable(String), + attempt: T.nilable(Integer), + last_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + build_id_redirect_counter: T.nilable(Integer) + ).void + end + def initialize( + scheduled_event_id: 0, + identity: "", + request_id: "", + attempt: 0, + last_failure: nil, + worker_version: nil, + build_id_redirect_counter: 0 + ) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this task corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this task corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this task corresponds to + sig { void } + def clear_scheduled_event_id + end + + # id of the worker that picked up this task + sig { returns(String) } + def identity + end + + # id of the worker that picked up this task + sig { params(value: String).void } + def identity=(value) + end + + # id of the worker that picked up this task + sig { void } + def clear_identity + end + + # This field is populated from the RecordActivityTaskStartedRequest. Matching service would +# set the request_id on the RecordActivityTaskStartedRequest to a new UUID. This is useful +# in case a RecordActivityTaskStarted call succeed but matching doesn't get that response, +# so matching could retry and history service would return success if the request_id matches. +# In that case, matching will continue to deliver the task to worker. Without this field, history +# service would return AlreadyStarted error, and matching would drop the task. + sig { returns(String) } + def request_id + end + + # This field is populated from the RecordActivityTaskStartedRequest. Matching service would +# set the request_id on the RecordActivityTaskStartedRequest to a new UUID. This is useful +# in case a RecordActivityTaskStarted call succeed but matching doesn't get that response, +# so matching could retry and history service would return success if the request_id matches. +# In that case, matching will continue to deliver the task to worker. Without this field, history +# service would return AlreadyStarted error, and matching would drop the task. + sig { params(value: String).void } + def request_id=(value) + end + + # This field is populated from the RecordActivityTaskStartedRequest. Matching service would +# set the request_id on the RecordActivityTaskStartedRequest to a new UUID. This is useful +# in case a RecordActivityTaskStarted call succeed but matching doesn't get that response, +# so matching could retry and history service would return success if the request_id matches. +# In that case, matching will continue to deliver the task to worker. Without this field, history +# service would return AlreadyStarted error, and matching would drop the task. + sig { void } + def clear_request_id + end + + # Starting at 1, the number of times this task has been attempted + sig { returns(Integer) } + def attempt + end + + # Starting at 1, the number of times this task has been attempted + sig { params(value: Integer).void } + def attempt=(value) + end + + # Starting at 1, the number of times this task has been attempted + sig { void } + def clear_attempt + end + + # Will be set to the most recent failure details, if this task has previously failed and then +# been retried. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_failure + end + + # Will be set to the most recent failure details, if this task has previously failed and then +# been retried. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_failure=(value) + end + + # Will be set to the most recent failure details, if this task has previously failed and then +# been retried. + sig { void } + def clear_last_failure + end + + # Version info of the worker to whom this task was dispatched. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker to whom this task was dispatched. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker to whom this task was dispatched. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_worker_version + end + + # Used by server internally to properly reapply build ID redirects to an execution +# when rebuilding it from events. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(Integer) } + def build_id_redirect_counter + end + + # Used by server internally to properly reapply build ID redirects to an execution +# when rebuilding it from events. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: Integer).void } + def build_id_redirect_counter=(value) + end + + # Used by server internally to properly reapply build ID redirects to an execution +# when rebuilding it from events. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_build_id_redirect_counter + 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::History::V1::ActivityTaskStartedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskStartedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ActivityTaskStartedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskStartedEventAttributes, 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::History::V1::ActivityTaskCompletedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result: T.nilable(Temporalio::Api::Common::V1::Payloads), + scheduled_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + identity: T.nilable(String), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp) + ).void + end + def initialize( + result: nil, + scheduled_event_id: 0, + started_event_id: 0, + identity: "", + worker_version: nil + ) + end + + # Serialized results of the activity. IE: The return value of the activity function + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def result + end + + # Serialized results of the activity. IE: The return value of the activity function + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def result=(value) + end + + # Serialized results of the activity. IE: The return value of the activity function + sig { void } + def clear_result + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this completion corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this completion corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this completion corresponds to + sig { void } + def clear_scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_STARTED` event this completion corresponds to + sig { returns(Integer) } + def started_event_id + end + + # The id of the `ACTIVITY_TASK_STARTED` event this completion corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_STARTED` event this completion corresponds to + sig { void } + def clear_started_event_id + end + + # id of the worker that completed this task + sig { returns(String) } + def identity + end + + # id of the worker that completed this task + sig { params(value: String).void } + def identity=(value) + end + + # id of the worker that completed this task + sig { void } + def clear_identity + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_worker_version + 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::History::V1::ActivityTaskCompletedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskCompletedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ActivityTaskCompletedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskCompletedEventAttributes, 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::History::V1::ActivityTaskFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + scheduled_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + identity: T.nilable(String), + retry_state: T.nilable(T.any(Symbol, String, Integer)), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp) + ).void + end + def initialize( + failure: nil, + scheduled_event_id: 0, + started_event_id: 0, + identity: "", + retry_state: :RETRY_STATE_UNSPECIFIED, + worker_version: nil + ) + end + + # Failure details + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Failure details + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Failure details + sig { void } + def clear_failure + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this failure corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this failure corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this failure corresponds to + sig { void } + def clear_scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_STARTED` event this failure corresponds to + sig { returns(Integer) } + def started_event_id + end + + # The id of the `ACTIVITY_TASK_STARTED` event this failure corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_STARTED` event this failure corresponds to + sig { void } + def clear_started_event_id + end + + # id of the worker that failed this task + sig { returns(String) } + def identity + end + + # id of the worker that failed this task + sig { params(value: String).void } + def identity=(value) + end + + # id of the worker that failed this task + sig { void } + def clear_identity + end + + sig { returns(T.any(Symbol, Integer)) } + def retry_state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_state=(value) + end + + sig { void } + def clear_retry_state + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_worker_version + 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::History::V1::ActivityTaskFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ActivityTaskFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskFailedEventAttributes, 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::History::V1::ActivityTaskTimedOutEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + scheduled_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + retry_state: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + failure: nil, + scheduled_event_id: 0, + started_event_id: 0, + retry_state: :RETRY_STATE_UNSPECIFIED + ) + end + + # If this activity had failed, was retried, and then timed out, that failure is stored as the +# `cause` in here. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # If this activity had failed, was retried, and then timed out, that failure is stored as the +# `cause` in here. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # If this activity had failed, was retried, and then timed out, that failure is stored as the +# `cause` in here. + sig { void } + def clear_failure + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this timeout corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this timeout corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this timeout corresponds to + sig { void } + def clear_scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_STARTED` event this timeout corresponds to + sig { returns(Integer) } + def started_event_id + end + + # The id of the `ACTIVITY_TASK_STARTED` event this timeout corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_STARTED` event this timeout corresponds to + sig { void } + def clear_started_event_id + end + + sig { returns(T.any(Symbol, Integer)) } + def retry_state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_state=(value) + end + + sig { void } + def clear_retry_state + 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::History::V1::ActivityTaskTimedOutEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskTimedOutEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ActivityTaskTimedOutEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskTimedOutEventAttributes, 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::History::V1::ActivityTaskCancelRequestedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + workflow_task_completed_event_id: T.nilable(Integer) + ).void + end + def initialize( + scheduled_event_id: 0, + workflow_task_completed_event_id: 0 + ) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this cancel request corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this cancel request corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this cancel request corresponds to + sig { void } + def clear_scheduled_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_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::History::V1::ActivityTaskCancelRequestedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskCancelRequestedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ActivityTaskCancelRequestedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskCancelRequestedEventAttributes, 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::History::V1::ActivityTaskCanceledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + latest_cancel_requested_event_id: T.nilable(Integer), + scheduled_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + identity: T.nilable(String), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp) + ).void + end + def initialize( + details: nil, + latest_cancel_requested_event_id: 0, + scheduled_event_id: 0, + started_event_id: 0, + identity: "", + worker_version: nil + ) + end + + # Additional information that the activity reported upon confirming cancellation + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + # Additional information that the activity reported upon confirming cancellation + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + # Additional information that the activity reported upon confirming cancellation + sig { void } + def clear_details + end + + # id of the most recent `ACTIVITY_TASK_CANCEL_REQUESTED` event which refers to the same +# activity + sig { returns(Integer) } + def latest_cancel_requested_event_id + end + + # id of the most recent `ACTIVITY_TASK_CANCEL_REQUESTED` event which refers to the same +# activity + sig { params(value: Integer).void } + def latest_cancel_requested_event_id=(value) + end + + # id of the most recent `ACTIVITY_TASK_CANCEL_REQUESTED` event which refers to the same +# activity + sig { void } + def clear_latest_cancel_requested_event_id + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this cancel confirmation corresponds to + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this cancel confirmation corresponds to + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this cancel confirmation corresponds to + sig { void } + def clear_scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_STARTED` event this cancel confirmation corresponds to + sig { returns(Integer) } + def started_event_id + end + + # The id of the `ACTIVITY_TASK_STARTED` event this cancel confirmation corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_STARTED` event this cancel confirmation corresponds to + sig { void } + def clear_started_event_id + end + + # id of the worker who canceled this activity + sig { returns(String) } + def identity + end + + # id of the worker who canceled this activity + sig { params(value: String).void } + def identity=(value) + end + + # id of the worker who canceled this activity + sig { void } + def clear_identity + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this workflow task. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_worker_version + 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::History::V1::ActivityTaskCanceledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskCanceledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ActivityTaskCanceledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityTaskCanceledEventAttributes, 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::History::V1::TimerStartedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + timer_id: T.nilable(String), + start_to_fire_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_completed_event_id: T.nilable(Integer) + ).void + end + def initialize( + timer_id: "", + start_to_fire_timeout: nil, + workflow_task_completed_event_id: 0 + ) + end + + # The worker/user assigned id for this timer + sig { returns(String) } + def timer_id + end + + # The worker/user assigned id for this timer + sig { params(value: String).void } + def timer_id=(value) + end + + # The worker/user assigned id for this timer + sig { void } + def clear_timer_id + end + + # How long until this timer fires +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_fire_timeout + end + + # How long until this timer fires +# +# (-- 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 start_to_fire_timeout=(value) + end + + # How long until this timer fires +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_fire_timeout + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_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::History::V1::TimerStartedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::TimerStartedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::TimerStartedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::TimerStartedEventAttributes, 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::History::V1::TimerFiredEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + timer_id: T.nilable(String), + started_event_id: T.nilable(Integer) + ).void + end + def initialize( + timer_id: "", + started_event_id: 0 + ) + end + + # Will match the `timer_id` from `TIMER_STARTED` event for this timer + sig { returns(String) } + def timer_id + end + + # Will match the `timer_id` from `TIMER_STARTED` event for this timer + sig { params(value: String).void } + def timer_id=(value) + end + + # Will match the `timer_id` from `TIMER_STARTED` event for this timer + sig { void } + def clear_timer_id + end + + # The id of the `TIMER_STARTED` event itself + sig { returns(Integer) } + def started_event_id + end + + # The id of the `TIMER_STARTED` event itself + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `TIMER_STARTED` event itself + sig { void } + def clear_started_event_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::History::V1::TimerFiredEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::TimerFiredEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::TimerFiredEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::TimerFiredEventAttributes, 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::History::V1::TimerCanceledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + timer_id: T.nilable(String), + started_event_id: T.nilable(Integer), + workflow_task_completed_event_id: T.nilable(Integer), + identity: T.nilable(String) + ).void + end + def initialize( + timer_id: "", + started_event_id: 0, + workflow_task_completed_event_id: 0, + identity: "" + ) + end + + # Will match the `timer_id` from `TIMER_STARTED` event for this timer + sig { returns(String) } + def timer_id + end + + # Will match the `timer_id` from `TIMER_STARTED` event for this timer + sig { params(value: String).void } + def timer_id=(value) + end + + # Will match the `timer_id` from `TIMER_STARTED` event for this timer + sig { void } + def clear_timer_id + end + + # The id of the `TIMER_STARTED` event itself + sig { returns(Integer) } + def started_event_id + end + + # The id of the `TIMER_STARTED` event itself + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the `TIMER_STARTED` event itself + sig { void } + def clear_started_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # The id of the worker who requested this cancel + sig { returns(String) } + def identity + end + + # The id of the worker who requested this cancel + sig { params(value: String).void } + def identity=(value) + end + + # The id of the worker who requested this cancel + sig { void } + def clear_identity + 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::History::V1::TimerCanceledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::TimerCanceledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::TimerCanceledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::TimerCanceledEventAttributes, 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::History::V1::WorkflowExecutionCancelRequestedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cause: T.nilable(String), + external_initiated_event_id: T.nilable(Integer), + external_workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + identity: T.nilable(String) + ).void + end + def initialize( + cause: "", + external_initiated_event_id: 0, + external_workflow_execution: nil, + identity: "" + ) + end + + # User provided reason for requesting cancellation + sig { returns(String) } + def cause + end + + # User provided reason for requesting cancellation + sig { params(value: String).void } + def cause=(value) + end + + # User provided reason for requesting cancellation + sig { void } + def clear_cause + end + + # The ID of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event in the external +# workflow history when the cancellation was requested by another workflow. + sig { returns(Integer) } + def external_initiated_event_id + end + + # The ID of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event in the external +# workflow history when the cancellation was requested by another workflow. + sig { params(value: Integer).void } + def external_initiated_event_id=(value) + end + + # The ID of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event in the external +# workflow history when the cancellation was requested by another workflow. + sig { void } + def clear_external_initiated_event_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def external_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def external_workflow_execution=(value) + end + + sig { void } + def clear_external_workflow_execution + end + + # id of the worker or client who requested this cancel + sig { returns(String) } + def identity + end + + # id of the worker or client who requested this cancel + sig { params(value: String).void } + def identity=(value) + end + + # id of the worker or client who requested this cancel + sig { void } + def clear_identity + 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::History::V1::WorkflowExecutionCancelRequestedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionCancelRequestedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionCancelRequestedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionCancelRequestedEventAttributes, 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::History::V1::WorkflowExecutionCanceledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_task_completed_event_id: T.nilable(Integer), + details: T.nilable(Temporalio::Api::Common::V1::Payloads) + ).void + end + def initialize( + workflow_task_completed_event_id: 0, + details: nil + ) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + sig { void } + def clear_details + 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::History::V1::WorkflowExecutionCanceledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionCanceledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionCanceledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionCanceledEventAttributes, 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::History::V1::MarkerRecordedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + marker_name: T.nilable(String), + details: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payloads)]), + workflow_task_completed_event_id: T.nilable(Integer), + header: T.nilable(Temporalio::Api::Common::V1::Header), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + marker_name: "", + details: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payloads), + workflow_task_completed_event_id: 0, + header: nil, + failure: nil + ) + end + + # Workers use this to identify the "types" of various markers. Ex: Local activity, side effect. + sig { returns(String) } + def marker_name + end + + # Workers use this to identify the "types" of various markers. Ex: Local activity, side effect. + sig { params(value: String).void } + def marker_name=(value) + end + + # Workers use this to identify the "types" of various markers. Ex: Local activity, side effect. + sig { void } + def clear_marker_name + end + + # Serialized information recorded in the marker + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payloads)]) } + def details + end + + # Serialized information recorded in the marker + sig { params(value: ::Google::Protobuf::Map).void } + def details=(value) + end + + # Serialized information recorded in the marker + sig { void } + def clear_details + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + # Some uses of markers, like a local activity, could "fail". If they did that is recorded here. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Some uses of markers, like a local activity, could "fail". If they did that is recorded here. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Some uses of markers, like a local activity, could "fail". If they did that is recorded here. + sig { void } + def clear_failure + 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::History::V1::MarkerRecordedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::MarkerRecordedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::MarkerRecordedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::MarkerRecordedEventAttributes, 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::History::V1::WorkflowExecutionSignaledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + signal_name: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + header: T.nilable(Temporalio::Api::Common::V1::Header), + skip_generate_workflow_task: T.nilable(T::Boolean), + external_workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + request_id: T.nilable(String) + ).void + end + def initialize( + signal_name: "", + input: nil, + identity: "", + header: nil, + skip_generate_workflow_task: false, + external_workflow_execution: nil, + request_id: "" + ) + end + + # The name/type of the signal to fire + sig { returns(String) } + def signal_name + end + + # The name/type of the signal to fire + sig { params(value: String).void } + def signal_name=(value) + end + + # The name/type of the signal to fire + sig { void } + def clear_signal_name + end + + # Will be deserialized and provided as argument(s) to the signal handler + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Will be deserialized and provided as argument(s) to the signal handler + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Will be deserialized and provided as argument(s) to the signal handler + sig { void } + def clear_input + end + + # id of the worker/client who sent this signal + sig { returns(String) } + def identity + end + + # id of the worker/client who sent this signal + sig { params(value: String).void } + def identity=(value) + end + + # id of the worker/client who sent this signal + sig { void } + def clear_identity + end + + # Headers that were passed by the sender of the signal and copied by temporal +# server into the workflow task. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Headers that were passed by the sender of the signal and copied by temporal +# server into the workflow task. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Headers that were passed by the sender of the signal and copied by temporal +# server into the workflow task. + sig { void } + def clear_header + end + + # Deprecated. This field is never respected and should always be set to false. + sig { returns(T::Boolean) } + def skip_generate_workflow_task + end + + # Deprecated. This field is never respected and should always be set to false. + sig { params(value: T::Boolean).void } + def skip_generate_workflow_task=(value) + end + + # Deprecated. This field is never respected and should always be set to false. + sig { void } + def clear_skip_generate_workflow_task + end + + # When signal origin is a workflow execution, this field is set. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def external_workflow_execution + end + + # When signal origin is a workflow execution, this field is set. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def external_workflow_execution=(value) + end + + # When signal origin is a workflow execution, this field is set. + sig { void } + def clear_external_workflow_execution + end + + # The request ID of the Signal request, used by the server to attach this to +# the correct Event ID when generating link. + sig { returns(String) } + def request_id + end + + # The request ID of the Signal request, used by the server to attach this to +# the correct Event ID when generating link. + sig { params(value: String).void } + def request_id=(value) + end + + # The request ID of the Signal request, used by the server to attach this to +# the correct Event ID when generating link. + sig { void } + def clear_request_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::History::V1::WorkflowExecutionSignaledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionSignaledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionSignaledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionSignaledEventAttributes, 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::History::V1::WorkflowExecutionTerminatedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + reason: T.nilable(String), + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String) + ).void + end + def initialize( + reason: "", + details: nil, + identity: "" + ) + end + + # User/client provided reason for termination + sig { returns(String) } + def reason + end + + # User/client provided reason for termination + sig { params(value: String).void } + def reason=(value) + end + + # User/client provided reason for termination + sig { void } + def clear_reason + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + sig { void } + def clear_details + end + + # id of the client who requested termination + sig { returns(String) } + def identity + end + + # id of the client who requested termination + sig { params(value: String).void } + def identity=(value) + end + + # id of the client who requested termination + sig { void } + def clear_identity + 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::History::V1::WorkflowExecutionTerminatedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionTerminatedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionTerminatedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionTerminatedEventAttributes, 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::History::V1::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_task_completed_event_id: T.nilable(Integer), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + control: T.nilable(String), + child_workflow_only: T.nilable(T::Boolean), + reason: T.nilable(String) + ).void + end + def initialize( + workflow_task_completed_event_id: 0, + namespace: "", + namespace_id: "", + workflow_execution: nil, + control: "", + child_workflow_only: false, + reason: "" + ) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # The namespace the workflow to be cancelled lives in. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # The namespace the workflow to be cancelled lives in. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace the workflow to be cancelled lives in. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + end + + # Workers are expected to set this to true if the workflow they are requesting to cancel is +# a child of the workflow which issued the request + sig { returns(T::Boolean) } + def child_workflow_only + end + + # Workers are expected to set this to true if the workflow they are requesting to cancel is +# a child of the workflow which issued the request + sig { params(value: T::Boolean).void } + def child_workflow_only=(value) + end + + # Workers are expected to set this to true if the workflow they are requesting to cancel is +# a child of the workflow which issued the request + sig { void } + def clear_child_workflow_only + end + + # Reason for requesting the cancellation + sig { returns(String) } + def reason + end + + # Reason for requesting the cancellation + sig { params(value: String).void } + def reason=(value) + end + + # Reason for requesting the cancellation + sig { void } + def clear_reason + 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::History::V1::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes, 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::History::V1::RequestCancelExternalWorkflowExecutionFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cause: T.nilable(T.any(Symbol, String, Integer)), + workflow_task_completed_event_id: T.nilable(Integer), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + initiated_event_id: T.nilable(Integer), + control: T.nilable(String) + ).void + end + def initialize( + cause: :CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED, + workflow_task_completed_event_id: 0, + namespace: "", + namespace_id: "", + workflow_execution: nil, + initiated_event_id: 0, + control: "" + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def cause + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def cause=(value) + end + + sig { void } + def clear_cause + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # Namespace of the workflow which failed to cancel. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which failed to cancel. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which failed to cancel. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + # id of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this failure +# corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # id of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this failure +# corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # id of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this failure +# corresponds to + sig { void } + def clear_initiated_event_id + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + 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::History::V1::RequestCancelExternalWorkflowExecutionFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionFailedEventAttributes, 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::History::V1::ExternalWorkflowExecutionCancelRequestedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + initiated_event_id: T.nilable(Integer), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution) + ).void + end + def initialize( + initiated_event_id: 0, + namespace: "", + namespace_id: "", + workflow_execution: nil + ) + end + + # id of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this event corresponds +# to + sig { returns(Integer) } + def initiated_event_id + end + + # id of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this event corresponds +# to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # id of the `REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this event corresponds +# to + sig { void } + def clear_initiated_event_id + end + + # Namespace of the to-be-cancelled workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the to-be-cancelled workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the to-be-cancelled workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + 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::History::V1::ExternalWorkflowExecutionCancelRequestedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ExternalWorkflowExecutionCancelRequestedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ExternalWorkflowExecutionCancelRequestedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ExternalWorkflowExecutionCancelRequestedEventAttributes, 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::History::V1::SignalExternalWorkflowExecutionInitiatedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_task_completed_event_id: T.nilable(Integer), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + signal_name: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + control: T.nilable(String), + child_workflow_only: T.nilable(T::Boolean), + header: T.nilable(Temporalio::Api::Common::V1::Header) + ).void + end + def initialize( + workflow_task_completed_event_id: 0, + namespace: "", + namespace_id: "", + workflow_execution: nil, + signal_name: "", + input: nil, + control: "", + child_workflow_only: false, + header: nil + ) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # Namespace of the to-be-signalled workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the to-be-signalled workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the to-be-signalled workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + # name/type of the signal to fire in the external workflow + sig { returns(String) } + def signal_name + end + + # name/type of the signal to fire in the external workflow + sig { params(value: String).void } + def signal_name=(value) + end + + # name/type of the signal to fire in the external workflow + sig { void } + def clear_signal_name + end + + # Serialized arguments to provide to the signal handler + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized arguments to provide to the signal handler + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized arguments to provide to the signal handler + sig { void } + def clear_input + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + end + + # Workers are expected to set this to true if the workflow they are requesting to cancel is +# a child of the workflow which issued the request + sig { returns(T::Boolean) } + def child_workflow_only + end + + # Workers are expected to set this to true if the workflow they are requesting to cancel is +# a child of the workflow which issued the request + sig { params(value: T::Boolean).void } + def child_workflow_only=(value) + end + + # Workers are expected to set this to true if the workflow they are requesting to cancel is +# a child of the workflow which issued the request + sig { void } + def clear_child_workflow_only + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + 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::History::V1::SignalExternalWorkflowExecutionInitiatedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::SignalExternalWorkflowExecutionInitiatedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::SignalExternalWorkflowExecutionInitiatedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::SignalExternalWorkflowExecutionInitiatedEventAttributes, 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::History::V1::SignalExternalWorkflowExecutionFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cause: T.nilable(T.any(Symbol, String, Integer)), + workflow_task_completed_event_id: T.nilable(Integer), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + initiated_event_id: T.nilable(Integer), + control: T.nilable(String) + ).void + end + def initialize( + cause: :SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED, + workflow_task_completed_event_id: 0, + namespace: "", + namespace_id: "", + workflow_execution: nil, + initiated_event_id: 0, + control: "" + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def cause + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def cause=(value) + end + + sig { void } + def clear_cause + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # Namespace of the workflow which failed the signal. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which failed the signal. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which failed the signal. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(Integer) } + def initiated_event_id + end + + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + sig { void } + def clear_initiated_event_id + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + 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::History::V1::SignalExternalWorkflowExecutionFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::SignalExternalWorkflowExecutionFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::SignalExternalWorkflowExecutionFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::SignalExternalWorkflowExecutionFailedEventAttributes, 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::History::V1::ExternalWorkflowExecutionSignaledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + initiated_event_id: T.nilable(Integer), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + control: T.nilable(String) + ).void + end + def initialize( + initiated_event_id: 0, + namespace: "", + namespace_id: "", + workflow_execution: nil, + control: "" + ) + end + + # id of the `SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this event corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # id of the `SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this event corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # id of the `SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED` event this event corresponds to + sig { void } + def clear_initiated_event_id + end + + # Namespace of the workflow which was signaled. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which was signaled. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which was signaled. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + 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::History::V1::ExternalWorkflowExecutionSignaledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ExternalWorkflowExecutionSignaledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ExternalWorkflowExecutionSignaledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ExternalWorkflowExecutionSignaledEventAttributes, 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::History::V1::UpsertWorkflowSearchAttributesEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_task_completed_event_id: T.nilable(Integer), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes) + ).void + end + def initialize( + workflow_task_completed_event_id: 0, + search_attributes: nil + ) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + 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::History::V1::UpsertWorkflowSearchAttributesEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::UpsertWorkflowSearchAttributesEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::UpsertWorkflowSearchAttributesEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::UpsertWorkflowSearchAttributesEventAttributes, 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::History::V1::WorkflowPropertiesModifiedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_task_completed_event_id: T.nilable(Integer), + upserted_memo: T.nilable(Temporalio::Api::Common::V1::Memo) + ).void + end + def initialize( + workflow_task_completed_event_id: 0, + upserted_memo: nil + ) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def upserted_memo + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def upserted_memo=(value) + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { void } + def clear_upserted_memo + 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::History::V1::WorkflowPropertiesModifiedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowPropertiesModifiedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowPropertiesModifiedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowPropertiesModifiedEventAttributes, 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::History::V1::StartChildWorkflowExecutionInitiatedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_id: T.nilable(String), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + parent_close_policy: T.nilable(T.any(Symbol, String, Integer)), + control: T.nilable(String), + workflow_task_completed_event_id: T.nilable(Integer), + workflow_id_reuse_policy: T.nilable(T.any(Symbol, String, Integer)), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + cron_schedule: T.nilable(String), + header: T.nilable(Temporalio::Api::Common::V1::Header), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + inherit_build_id: T.nilable(T::Boolean), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + time_skipping_config: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig), + initial_skipped_duration: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + namespace: "", + namespace_id: "", + workflow_id: "", + workflow_type: nil, + task_queue: nil, + input: nil, + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + parent_close_policy: :PARENT_CLOSE_POLICY_UNSPECIFIED, + control: "", + workflow_task_completed_event_id: 0, + workflow_id_reuse_policy: :WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED, + retry_policy: nil, + cron_schedule: "", + header: nil, + memo: nil, + search_attributes: nil, + inherit_build_id: false, + priority: nil, + time_skipping_config: nil, + initial_skipped_duration: nil + ) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + sig { void } + def clear_input + end + + # Total workflow execution timeout including retries and continue as new. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + # Total workflow execution timeout including retries and continue as new. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + # Total workflow execution timeout including retries and continue as new. + sig { void } + def clear_workflow_execution_timeout + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { returns(T.any(Symbol, Integer)) } + def parent_close_policy + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def parent_close_policy=(value) + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { void } + def clear_parent_close_policy + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_id + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { returns(T.any(Symbol, Integer)) } + def workflow_id_reuse_policy + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def workflow_id_reuse_policy=(value) + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { void } + def clear_workflow_id_reuse_policy + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + sig { void } + def clear_retry_policy + end + + # If this child runs on a cron schedule, it will appear here + sig { returns(String) } + def cron_schedule + end + + # If this child runs on a cron schedule, it will appear here + sig { params(value: String).void } + def cron_schedule=(value) + end + + # If this child runs on a cron schedule, it will appear here + sig { void } + def clear_cron_schedule + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + # If this is set, the child workflow inherits the Build ID of the parent. Otherwise, the assignment +# rules of the child's Task Queue will be used to independently assign a Build ID to it. +# Deprecated. Only considered for versioning v0.2. + sig { returns(T::Boolean) } + def inherit_build_id + end + + # If this is set, the child workflow inherits the Build ID of the parent. Otherwise, the assignment +# rules of the child's Task Queue will be used to independently assign a Build ID to it. +# Deprecated. Only considered for versioning v0.2. + sig { params(value: T::Boolean).void } + def inherit_build_id=(value) + end + + # If this is set, the child workflow inherits the Build ID of the parent. Otherwise, the assignment +# rules of the child's Task Queue will be used to independently assign a Build ID to it. +# Deprecated. Only considered for versioning v0.2. + sig { void } + def clear_inherit_build_id + end + + # Priority metadata + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata + sig { void } + def clear_priority + end + + # The propagated time-skipping configuration for the child workflow. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)) } + def time_skipping_config + end + + # The propagated time-skipping configuration for the child workflow. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)).void } + def time_skipping_config=(value) + end + + # The propagated time-skipping configuration for the child workflow. + sig { void } + def clear_time_skipping_config + end + + # Propagate the duration skipped to the child workflow. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def initial_skipped_duration + end + + # Propagate the duration skipped to the child workflow. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def initial_skipped_duration=(value) + end + + # Propagate the duration skipped to the child workflow. + sig { void } + def clear_initial_skipped_duration + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::History::V1::StartChildWorkflowExecutionInitiatedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::StartChildWorkflowExecutionInitiatedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::StartChildWorkflowExecutionInitiatedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::StartChildWorkflowExecutionInitiatedEventAttributes, 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::History::V1::StartChildWorkflowExecutionFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_id: T.nilable(String), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + cause: T.nilable(T.any(Symbol, String, Integer)), + control: T.nilable(String), + initiated_event_id: T.nilable(Integer), + workflow_task_completed_event_id: T.nilable(Integer) + ).void + end + def initialize( + namespace: "", + namespace_id: "", + workflow_id: "", + workflow_type: nil, + cause: :START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED, + control: "", + initiated_event_id: 0, + workflow_task_completed_event_id: 0 + ) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.any(Symbol, Integer)) } + def cause + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def cause=(value) + end + + sig { void } + def clear_cause + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { void } + def clear_initiated_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event which this command was reported with + sig { void } + def clear_workflow_task_completed_event_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::History::V1::StartChildWorkflowExecutionFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::StartChildWorkflowExecutionFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::StartChildWorkflowExecutionFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::StartChildWorkflowExecutionFailedEventAttributes, 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::History::V1::ChildWorkflowExecutionStartedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + namespace_id: T.nilable(String), + initiated_event_id: T.nilable(Integer), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + header: T.nilable(Temporalio::Api::Common::V1::Header) + ).void + end + def initialize( + namespace: "", + namespace_id: "", + initiated_event_id: 0, + workflow_execution: nil, + workflow_type: nil, + header: nil + ) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { void } + def clear_initiated_event_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + 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::History::V1::ChildWorkflowExecutionStartedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionStartedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ChildWorkflowExecutionStartedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionStartedEventAttributes, 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::History::V1::ChildWorkflowExecutionCompletedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result: T.nilable(Temporalio::Api::Common::V1::Payloads), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + initiated_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer) + ).void + end + def initialize( + result: nil, + namespace: "", + namespace_id: "", + workflow_execution: nil, + workflow_type: nil, + initiated_event_id: 0, + started_event_id: 0 + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def result=(value) + end + + sig { void } + def clear_result + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { void } + def clear_initiated_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { returns(Integer) } + def started_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { void } + def clear_started_event_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::History::V1::ChildWorkflowExecutionCompletedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionCompletedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ChildWorkflowExecutionCompletedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionCompletedEventAttributes, 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::History::V1::ChildWorkflowExecutionFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + initiated_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + retry_state: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + failure: nil, + namespace: "", + namespace_id: "", + workflow_execution: nil, + workflow_type: nil, + initiated_event_id: 0, + started_event_id: 0, + retry_state: :RETRY_STATE_UNSPECIFIED + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { void } + def clear_initiated_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { returns(Integer) } + def started_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { void } + def clear_started_event_id + end + + sig { returns(T.any(Symbol, Integer)) } + def retry_state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_state=(value) + end + + sig { void } + def clear_retry_state + 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::History::V1::ChildWorkflowExecutionFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ChildWorkflowExecutionFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionFailedEventAttributes, 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::History::V1::ChildWorkflowExecutionCanceledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + initiated_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer) + ).void + end + def initialize( + details: nil, + namespace: "", + namespace_id: "", + workflow_execution: nil, + workflow_type: nil, + initiated_event_id: 0, + started_event_id: 0 + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + sig { void } + def clear_details + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { void } + def clear_initiated_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { returns(Integer) } + def started_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { void } + def clear_started_event_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::History::V1::ChildWorkflowExecutionCanceledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionCanceledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ChildWorkflowExecutionCanceledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionCanceledEventAttributes, 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::History::V1::ChildWorkflowExecutionTimedOutEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + initiated_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + retry_state: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + namespace: "", + namespace_id: "", + workflow_execution: nil, + workflow_type: nil, + initiated_event_id: 0, + started_event_id: 0, + retry_state: :RETRY_STATE_UNSPECIFIED + ) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { void } + def clear_initiated_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { returns(Integer) } + def started_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { void } + def clear_started_event_id + end + + sig { returns(T.any(Symbol, Integer)) } + def retry_state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_state=(value) + end + + sig { void } + def clear_retry_state + 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::History::V1::ChildWorkflowExecutionTimedOutEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionTimedOutEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ChildWorkflowExecutionTimedOutEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionTimedOutEventAttributes, 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::History::V1::ChildWorkflowExecutionTerminatedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + namespace_id: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + initiated_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer) + ).void + end + def initialize( + namespace: "", + namespace_id: "", + workflow_execution: nil, + workflow_type: nil, + initiated_event_id: 0, + started_event_id: 0 + ) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { returns(String) } + def namespace + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the child workflow. +# SDKs and UI tools should use `namespace` field but server must use `namespace_id` only. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { returns(Integer) } + def initiated_event_id + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { params(value: Integer).void } + def initiated_event_id=(value) + end + + # Id of the `START_CHILD_WORKFLOW_EXECUTION_INITIATED` event which this event corresponds to + sig { void } + def clear_initiated_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { returns(Integer) } + def started_event_id + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # Id of the `CHILD_WORKFLOW_EXECUTION_STARTED` event which this event corresponds to + sig { void } + def clear_started_event_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::History::V1::ChildWorkflowExecutionTerminatedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionTerminatedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ChildWorkflowExecutionTerminatedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ChildWorkflowExecutionTerminatedEventAttributes, 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::History::V1::WorkflowExecutionOptionsUpdatedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + versioning_override: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride), + unset_versioning_override: T.nilable(T::Boolean), + attached_request_id: T.nilable(String), + attached_completion_callbacks: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Callback)]), + identity: T.nilable(String), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + time_skipping_config: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig) + ).void + end + def initialize( + versioning_override: nil, + unset_versioning_override: false, + attached_request_id: "", + attached_completion_callbacks: [], + identity: "", + priority: nil, + time_skipping_config: nil + ) + end + + # Versioning override upserted in this event. +# Ignored if nil or if unset_versioning_override is true. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)) } + def versioning_override + end + + # Versioning override upserted in this event. +# Ignored if nil or if unset_versioning_override is true. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)).void } + def versioning_override=(value) + end + + # Versioning override upserted in this event. +# Ignored if nil or if unset_versioning_override is true. + sig { void } + def clear_versioning_override + end + + # Versioning override removed in this event. + sig { returns(T::Boolean) } + def unset_versioning_override + end + + # Versioning override removed in this event. + sig { params(value: T::Boolean).void } + def unset_versioning_override=(value) + end + + # Versioning override removed in this event. + sig { void } + def clear_unset_versioning_override + end + + # Request ID attached to the running workflow execution so that subsequent requests with same +# request ID will be deduped. + sig { returns(String) } + def attached_request_id + end + + # Request ID attached to the running workflow execution so that subsequent requests with same +# request ID will be deduped. + sig { params(value: String).void } + def attached_request_id=(value) + end + + # Request ID attached to the running workflow execution so that subsequent requests with same +# request ID will be deduped. + sig { void } + def clear_attached_request_id + end + + # Completion callbacks attached to the running workflow execution. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Callback)]) } + def attached_completion_callbacks + end + + # Completion callbacks attached to the running workflow execution. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def attached_completion_callbacks=(value) + end + + # Completion callbacks attached to the running workflow execution. + sig { void } + def clear_attached_completion_callbacks + end + + # Optional. The identity of the client who initiated the request that created this event. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated the request that created this event. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated the request that created this event. + sig { void } + def clear_identity + end + + # Priority override upserted in this event. Represents the full priority; not just partial fields. +# Ignored if nil. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority override upserted in this event. Represents the full priority; not just partial fields. +# Ignored if nil. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority override upserted in this event. Represents the full priority; not just partial fields. +# Ignored if nil. + sig { void } + def clear_priority + end + + # If set, the time-skipping configuration was changed. Contains the full updated configuration. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)) } + def time_skipping_config + end + + # If set, the time-skipping configuration was changed. Contains the full updated configuration. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)).void } + def time_skipping_config=(value) + end + + # If set, the time-skipping configuration was changed. Contains the full updated configuration. + sig { void } + def clear_time_skipping_config + 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::History::V1::WorkflowExecutionOptionsUpdatedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionOptionsUpdatedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionOptionsUpdatedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionOptionsUpdatedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Not used anywhere. Use case is replaced by WorkflowExecutionOptionsUpdatedEventAttributes +class Temporalio::Api::History::V1::WorkflowPropertiesModifiedExternallyEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + new_task_queue: T.nilable(String), + new_workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + new_workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + new_workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + upserted_memo: T.nilable(Temporalio::Api::Common::V1::Memo) + ).void + end + def initialize( + new_task_queue: "", + new_workflow_task_timeout: nil, + new_workflow_run_timeout: nil, + new_workflow_execution_timeout: nil, + upserted_memo: nil + ) + end + + # Not used. + sig { returns(String) } + def new_task_queue + end + + # Not used. + sig { params(value: String).void } + def new_task_queue=(value) + end + + # Not used. + sig { void } + def clear_new_task_queue + end + + # Not used. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def new_workflow_task_timeout + end + + # Not used. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def new_workflow_task_timeout=(value) + end + + # Not used. + sig { void } + def clear_new_workflow_task_timeout + end + + # Not used. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def new_workflow_run_timeout + end + + # Not used. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def new_workflow_run_timeout=(value) + end + + # Not used. + sig { void } + def clear_new_workflow_run_timeout + end + + # Not used. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def new_workflow_execution_timeout + end + + # Not used. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def new_workflow_execution_timeout=(value) + end + + # Not used. + sig { void } + def clear_new_workflow_execution_timeout + end + + # Not used. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def upserted_memo + end + + # Not used. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def upserted_memo=(value) + end + + # Not used. + sig { void } + def clear_upserted_memo + 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::History::V1::WorkflowPropertiesModifiedExternallyEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowPropertiesModifiedExternallyEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowPropertiesModifiedExternallyEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowPropertiesModifiedExternallyEventAttributes, 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::History::V1::ActivityPropertiesModifiedExternallyEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + new_retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy) + ).void + end + def initialize( + scheduled_event_id: 0, + new_retry_policy: nil + ) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this modification corresponds to. + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this modification corresponds to. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `ACTIVITY_TASK_SCHEDULED` event this modification corresponds to. + sig { void } + def clear_scheduled_event_id + end + + # If set, update the retry policy of the activity, replacing it with the specified one. +# The number of attempts at the activity is preserved. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def new_retry_policy + end + + # If set, update the retry policy of the activity, replacing it with the specified one. +# The number of attempts at the activity is preserved. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def new_retry_policy=(value) + end + + # If set, update the retry policy of the activity, replacing it with the specified one. +# The number of attempts at the activity is preserved. + sig { void } + def clear_new_retry_policy + 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::History::V1::ActivityPropertiesModifiedExternallyEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityPropertiesModifiedExternallyEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::ActivityPropertiesModifiedExternallyEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::ActivityPropertiesModifiedExternallyEventAttributes, 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::History::V1::WorkflowExecutionUpdateAcceptedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + protocol_instance_id: T.nilable(String), + accepted_request_message_id: T.nilable(String), + accepted_request_sequencing_event_id: T.nilable(Integer), + accepted_request: T.nilable(Temporalio::Api::Update::V1::Request) + ).void + end + def initialize( + protocol_instance_id: "", + accepted_request_message_id: "", + accepted_request_sequencing_event_id: 0, + accepted_request: nil + ) + end + + # The instance ID of the update protocol that generated this event. + sig { returns(String) } + def protocol_instance_id + end + + # The instance ID of the update protocol that generated this event. + sig { params(value: String).void } + def protocol_instance_id=(value) + end + + # The instance ID of the update protocol that generated this event. + sig { void } + def clear_protocol_instance_id + end + + # The message ID of the original request message that initiated this +# update. Needed so that the worker can recreate and deliver that same +# message as part of replay. + sig { returns(String) } + def accepted_request_message_id + end + + # The message ID of the original request message that initiated this +# update. Needed so that the worker can recreate and deliver that same +# message as part of replay. + sig { params(value: String).void } + def accepted_request_message_id=(value) + end + + # The message ID of the original request message that initiated this +# update. Needed so that the worker can recreate and deliver that same +# message as part of replay. + sig { void } + def clear_accepted_request_message_id + end + + # The event ID used to sequence the original request message. + sig { returns(Integer) } + def accepted_request_sequencing_event_id + end + + # The event ID used to sequence the original request message. + sig { params(value: Integer).void } + def accepted_request_sequencing_event_id=(value) + end + + # The event ID used to sequence the original request message. + sig { void } + def clear_accepted_request_sequencing_event_id + end + + # The message payload of the original request message that initiated this +# update. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Request)) } + def accepted_request + end + + # The message payload of the original request message that initiated this +# update. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Request)).void } + def accepted_request=(value) + end + + # The message payload of the original request message that initiated this +# update. + sig { void } + def clear_accepted_request + 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::History::V1::WorkflowExecutionUpdateAcceptedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUpdateAcceptedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionUpdateAcceptedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUpdateAcceptedEventAttributes, 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::History::V1::WorkflowExecutionUpdateCompletedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + meta: T.nilable(Temporalio::Api::Update::V1::Meta), + accepted_event_id: T.nilable(Integer), + outcome: T.nilable(Temporalio::Api::Update::V1::Outcome) + ).void + end + def initialize( + meta: nil, + accepted_event_id: 0, + outcome: nil + ) + end + + # The metadata about this update. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Meta)) } + def meta + end + + # The metadata about this update. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Meta)).void } + def meta=(value) + end + + # The metadata about this update. + sig { void } + def clear_meta + end + + # The event ID indicating the acceptance of this update. + sig { returns(Integer) } + def accepted_event_id + end + + # The event ID indicating the acceptance of this update. + sig { params(value: Integer).void } + def accepted_event_id=(value) + end + + # The event ID indicating the acceptance of this update. + sig { void } + def clear_accepted_event_id + end + + # The outcome of executing the workflow update function. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Outcome)) } + def outcome + end + + # The outcome of executing the workflow update function. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Outcome)).void } + def outcome=(value) + end + + # The outcome of executing the workflow update function. + sig { void } + def clear_outcome + 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::History::V1::WorkflowExecutionUpdateCompletedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUpdateCompletedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionUpdateCompletedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUpdateCompletedEventAttributes, 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::History::V1::WorkflowExecutionUpdateRejectedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + protocol_instance_id: T.nilable(String), + rejected_request_message_id: T.nilable(String), + rejected_request_sequencing_event_id: T.nilable(Integer), + rejected_request: T.nilable(Temporalio::Api::Update::V1::Request), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + protocol_instance_id: "", + rejected_request_message_id: "", + rejected_request_sequencing_event_id: 0, + rejected_request: nil, + failure: nil + ) + end + + # The instance ID of the update protocol that generated this event. + sig { returns(String) } + def protocol_instance_id + end + + # The instance ID of the update protocol that generated this event. + sig { params(value: String).void } + def protocol_instance_id=(value) + end + + # The instance ID of the update protocol that generated this event. + sig { void } + def clear_protocol_instance_id + end + + # The message ID of the original request message that initiated this +# update. Needed so that the worker can recreate and deliver that same +# message as part of replay. + sig { returns(String) } + def rejected_request_message_id + end + + # The message ID of the original request message that initiated this +# update. Needed so that the worker can recreate and deliver that same +# message as part of replay. + sig { params(value: String).void } + def rejected_request_message_id=(value) + end + + # The message ID of the original request message that initiated this +# update. Needed so that the worker can recreate and deliver that same +# message as part of replay. + sig { void } + def clear_rejected_request_message_id + end + + # The event ID used to sequence the original request message. + sig { returns(Integer) } + def rejected_request_sequencing_event_id + end + + # The event ID used to sequence the original request message. + sig { params(value: Integer).void } + def rejected_request_sequencing_event_id=(value) + end + + # The event ID used to sequence the original request message. + sig { void } + def clear_rejected_request_sequencing_event_id + end + + # The message payload of the original request message that initiated this +# update. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Request)) } + def rejected_request + end + + # The message payload of the original request message that initiated this +# update. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Request)).void } + def rejected_request=(value) + end + + # The message payload of the original request message that initiated this +# update. + sig { void } + def clear_rejected_request + end + + # The cause of rejection. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The cause of rejection. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The cause of rejection. + sig { void } + def clear_failure + 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::History::V1::WorkflowExecutionUpdateRejectedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUpdateRejectedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionUpdateRejectedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUpdateRejectedEventAttributes, 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::History::V1::WorkflowExecutionUpdateAdmittedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + request: T.nilable(Temporalio::Api::Update::V1::Request), + origin: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + request: nil, + origin: :UPDATE_ADMITTED_EVENT_ORIGIN_UNSPECIFIED + ) + end + + # The update request associated with this event. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Request)) } + def request + end + + # The update request associated with this event. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Request)).void } + def request=(value) + end + + # The update request associated with this event. + sig { void } + def clear_request + end + + # An explanation of why this event was written to history. + sig { returns(T.any(Symbol, Integer)) } + def origin + end + + # An explanation of why this event was written to history. + sig { params(value: T.any(Symbol, String, Integer)).void } + def origin=(value) + end + + # An explanation of why this event was written to history. + sig { void } + def clear_origin + 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::History::V1::WorkflowExecutionUpdateAdmittedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUpdateAdmittedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionUpdateAdmittedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUpdateAdmittedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Attributes for an event marking that a workflow execution was paused. +class Temporalio::Api::History::V1::WorkflowExecutionPausedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + reason: T.nilable(String), + request_id: T.nilable(String) + ).void + end + def initialize( + identity: "", + reason: "", + request_id: "" + ) + end + + # The identity of the client who paused the workflow execution. + sig { returns(String) } + def identity + end + + # The identity of the client who paused the workflow execution. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who paused the workflow execution. + sig { void } + def clear_identity + end + + # The reason for pausing the workflow execution. + sig { returns(String) } + def reason + end + + # The reason for pausing the workflow execution. + sig { params(value: String).void } + def reason=(value) + end + + # The reason for pausing the workflow execution. + sig { void } + def clear_reason + end + + # The request ID of the request that paused the workflow execution. + sig { returns(String) } + def request_id + end + + # The request ID of the request that paused the workflow execution. + sig { params(value: String).void } + def request_id=(value) + end + + # The request ID of the request that paused the workflow execution. + sig { void } + def clear_request_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::History::V1::WorkflowExecutionPausedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionPausedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionPausedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionPausedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Attributes for an event marking that a workflow execution was unpaused. +class Temporalio::Api::History::V1::WorkflowExecutionUnpausedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + reason: T.nilable(String), + request_id: T.nilable(String) + ).void + end + def initialize( + identity: "", + reason: "", + request_id: "" + ) + end + + # The identity of the client who unpaused the workflow execution. + sig { returns(String) } + def identity + end + + # The identity of the client who unpaused the workflow execution. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who unpaused the workflow execution. + sig { void } + def clear_identity + end + + # The reason for unpausing the workflow execution. + sig { returns(String) } + def reason + end + + # The reason for unpausing the workflow execution. + sig { params(value: String).void } + def reason=(value) + end + + # The reason for unpausing the workflow execution. + sig { void } + def clear_reason + end + + # The request ID of the request that unpaused the workflow execution. + sig { returns(String) } + def request_id + end + + # The request ID of the request that unpaused the workflow execution. + sig { params(value: String).void } + def request_id=(value) + end + + # The request ID of the request that unpaused the workflow execution. + sig { void } + def clear_request_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::History::V1::WorkflowExecutionUnpausedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUnpausedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionUnpausedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionUnpausedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Attributes for an event indicating that time skipping state changed for a workflow execution, +# either time was advanced or time skipping was disabled automatically due to a bound being reached. +# The worker_may_ignore field in HistoryEvent should always be set true for this event. +class Temporalio::Api::History::V1::WorkflowExecutionTimeSkippingTransitionedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + target_time: T.nilable(Google::Protobuf::Timestamp), + disabled_after_bound: T.nilable(T::Boolean), + wall_clock_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + target_time: nil, + disabled_after_bound: false, + wall_clock_time: nil + ) + end + + # The virtual time after time skipping was applied. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def target_time + end + + # The virtual time after time skipping was applied. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def target_time=(value) + end + + # The virtual time after time skipping was applied. + sig { void } + def clear_target_time + end + + # when true, time skipping was disabled automatically due to a bound being reached. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "after" is used to indicate temporal ordering. --) + sig { returns(T::Boolean) } + def disabled_after_bound + end + + # when true, time skipping was disabled automatically due to a bound being reached. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "after" is used to indicate temporal ordering. --) + sig { params(value: T::Boolean).void } + def disabled_after_bound=(value) + end + + # when true, time skipping was disabled automatically due to a bound being reached. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "after" is used to indicate temporal ordering. --) + sig { void } + def clear_disabled_after_bound + end + + # The wall-clock time when the time-skipping state changed event was generated. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def wall_clock_time + end + + # The wall-clock time when the time-skipping state changed event was generated. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def wall_clock_time=(value) + end + + # The wall-clock time when the time-skipping state changed event was generated. + sig { void } + def clear_wall_clock_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::History::V1::WorkflowExecutionTimeSkippingTransitionedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionTimeSkippingTransitionedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::WorkflowExecutionTimeSkippingTransitionedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::WorkflowExecutionTimeSkippingTransitionedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Event marking that an operation was scheduled by a workflow via the ScheduleNexusOperation command. +class Temporalio::Api::History::V1::NexusOperationScheduledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint: T.nilable(String), + service: T.nilable(String), + operation: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payload), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + nexus_header: T.nilable(T::Hash[String, String]), + workflow_task_completed_event_id: T.nilable(Integer), + request_id: T.nilable(String), + endpoint_id: T.nilable(String), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + endpoint: "", + service: "", + operation: "", + input: nil, + schedule_to_close_timeout: nil, + nexus_header: ::Google::Protobuf::Map.new(:string, :string), + workflow_task_completed_event_id: 0, + request_id: "", + endpoint_id: "", + schedule_to_start_timeout: nil, + start_to_close_timeout: nil + ) + end + + # Endpoint name, must exist in the endpoint registry. + sig { returns(String) } + def endpoint + end + + # Endpoint name, must exist in the endpoint registry. + sig { params(value: String).void } + def endpoint=(value) + end + + # Endpoint name, must exist in the endpoint registry. + sig { void } + def clear_endpoint + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Operation name. + sig { returns(String) } + def operation + end + + # Operation name. + sig { params(value: String).void } + def operation=(value) + end + + # Operation name. + sig { void } + def clear_operation + end + + # Input for the operation. The server converts this into Nexus request content and the appropriate content headers +# internally when sending the StartOperation request. On the handler side, if it is also backed by Temporal, the +# content is transformed back to the original Payload stored in this event. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def input + end + + # Input for the operation. The server converts this into Nexus request content and the appropriate content headers +# internally when sending the StartOperation request. On the handler side, if it is also backed by Temporal, the +# content is transformed back to the original Payload stored in this event. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def input=(value) + end + + # Input for the operation. The server converts this into Nexus request content and the appropriate content headers +# internally when sending the StartOperation request. On the handler side, if it is also backed by Temporal, the +# content is transformed back to the original Payload stored in this event. + sig { void } + def clear_input + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: "timeout" is an acceptable suffix for duration fields in this API. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_close_timeout + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: "timeout" is an acceptable suffix for duration fields in this API. --) + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_close_timeout=(value) + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: "timeout" is an acceptable suffix for duration fields in this API. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Header to attach to the Nexus request. Note these headers are not the same as Temporal headers on internal +# activities and child workflows, these are transmitted to Nexus operations that may be external and are not +# traditional payloads. + sig { returns(T::Hash[String, String]) } + def nexus_header + end + + # Header to attach to the Nexus request. Note these headers are not the same as Temporal headers on internal +# activities and child workflows, these are transmitted to Nexus operations that may be external and are not +# traditional payloads. + sig { params(value: ::Google::Protobuf::Map).void } + def nexus_header=(value) + end + + # Header to attach to the Nexus request. Note these headers are not the same as Temporal headers on internal +# activities and child workflows, these are transmitted to Nexus operations that may be external and are not +# traditional payloads. + sig { void } + def clear_nexus_header + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding ScheduleNexusOperation command was reported with. + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding ScheduleNexusOperation command was reported with. + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding ScheduleNexusOperation command was reported with. + sig { void } + def clear_workflow_task_completed_event_id + end + + # A unique ID generated by the history service upon creation of this event. +# The ID will be transmitted with all nexus StartOperation requests and is used as an idempotentency key. + sig { returns(String) } + def request_id + end + + # A unique ID generated by the history service upon creation of this event. +# The ID will be transmitted with all nexus StartOperation requests and is used as an idempotentency key. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique ID generated by the history service upon creation of this event. +# The ID will be transmitted with all nexus StartOperation requests and is used as an idempotentency key. + sig { void } + def clear_request_id + end + + # Endpoint ID as resolved in the endpoint registry at the time this event was generated. +# This is stored on the event and used internally by the server in case the endpoint is renamed from the time the +# event was originally scheduled. + sig { returns(String) } + def endpoint_id + end + + # Endpoint ID as resolved in the endpoint registry at the time this event was generated. +# This is stored on the event and used internally by the server in case the endpoint is renamed from the time the +# event was originally scheduled. + sig { params(value: String).void } + def endpoint_id=(value) + end + + # Endpoint ID as resolved in the endpoint registry at the time this event was generated. +# This is stored on the event and used internally by the server in case the endpoint is renamed from the time the +# event was originally scheduled. + sig { void } + def clear_endpoint_id + end + + # Schedule-to-start timeout for this operation. +# See ScheduleNexusOperationCommandAttributes.schedule_to_start_timeout for details. +# (-- 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 + + # Schedule-to-start timeout for this operation. +# See ScheduleNexusOperationCommandAttributes.schedule_to_start_timeout for details. +# (-- 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 + + # Schedule-to-start timeout for this operation. +# See ScheduleNexusOperationCommandAttributes.schedule_to_start_timeout for details. +# (-- 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 + + # Start-to-close timeout for this operation. +# See ScheduleNexusOperationCommandAttributes.start_to_close_timeout for details. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Start-to-close timeout for this operation. +# See ScheduleNexusOperationCommandAttributes.start_to_close_timeout for details. +# (-- 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 start_to_close_timeout=(value) + end + + # Start-to-close timeout for this operation. +# See ScheduleNexusOperationCommandAttributes.start_to_close_timeout for details. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_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::History::V1::NexusOperationScheduledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationScheduledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationScheduledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationScheduledEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Event marking an asynchronous operation was started by the responding Nexus handler. +# If the operation completes synchronously, this event is not generated. +# In rare situations, such as request timeouts, the service may fail to record the actual start time and will fabricate +# this event upon receiving the operation completion via callback. +class Temporalio::Api::History::V1::NexusOperationStartedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + operation_id: T.nilable(String), + request_id: T.nilable(String), + operation_token: T.nilable(String) + ).void + end + def initialize( + scheduled_event_id: 0, + operation_id: "", + request_id: "", + operation_token: "" + ) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event this task corresponds to. + sig { returns(Integer) } + def scheduled_event_id + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event this task corresponds to. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event this task corresponds to. + sig { void } + def clear_scheduled_event_id + end + + # The operation ID returned by the Nexus handler in the response to the StartOperation request. +# This ID is used when canceling the operation. +# +# Deprecated: Renamed to operation_token. + sig { returns(String) } + def operation_id + end + + # The operation ID returned by the Nexus handler in the response to the StartOperation request. +# This ID is used when canceling the operation. +# +# Deprecated: Renamed to operation_token. + sig { params(value: String).void } + def operation_id=(value) + end + + # The operation ID returned by the Nexus handler in the response to the StartOperation request. +# This ID is used when canceling the operation. +# +# Deprecated: Renamed to operation_token. + sig { void } + def clear_operation_id + end + + # The request ID allocated at schedule time. + sig { returns(String) } + def request_id + end + + # The request ID allocated at schedule time. + sig { params(value: String).void } + def request_id=(value) + end + + # The request ID allocated at schedule time. + sig { void } + def clear_request_id + end + + # The operation token returned by the Nexus handler in the response to the StartOperation request. +# This token is used when canceling the operation. + sig { returns(String) } + def operation_token + end + + # The operation token returned by the Nexus handler in the response to the StartOperation request. +# This token is used when canceling the operation. + sig { params(value: String).void } + def operation_token=(value) + end + + # The operation token returned by the Nexus handler in the response to the StartOperation request. +# This token is used when canceling the operation. + sig { void } + def clear_operation_token + 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::History::V1::NexusOperationStartedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationStartedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationStartedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationStartedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Nexus operation completed successfully. +class Temporalio::Api::History::V1::NexusOperationCompletedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + result: T.nilable(Temporalio::Api::Common::V1::Payload), + request_id: T.nilable(String) + ).void + end + def initialize( + scheduled_event_id: 0, + result: nil, + request_id: "" + ) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { returns(Integer) } + def scheduled_event_id + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { void } + def clear_scheduled_event_id + end + + # Serialized result of the Nexus operation. The response of the Nexus handler. +# Delivered either via a completion callback or as a response to a synchronous operation. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def result + end + + # Serialized result of the Nexus operation. The response of the Nexus handler. +# Delivered either via a completion callback or as a response to a synchronous operation. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def result=(value) + end + + # Serialized result of the Nexus operation. The response of the Nexus handler. +# Delivered either via a completion callback or as a response to a synchronous operation. + sig { void } + def clear_result + end + + # The request ID allocated at schedule time. + sig { returns(String) } + def request_id + end + + # The request ID allocated at schedule time. + sig { params(value: String).void } + def request_id=(value) + end + + # The request ID allocated at schedule time. + sig { void } + def clear_request_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::History::V1::NexusOperationCompletedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCompletedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationCompletedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCompletedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Nexus operation failed. +class Temporalio::Api::History::V1::NexusOperationFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + request_id: T.nilable(String) + ).void + end + def initialize( + scheduled_event_id: 0, + failure: nil, + request_id: "" + ) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { returns(Integer) } + def scheduled_event_id + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { void } + def clear_scheduled_event_id + end + + # Failure details. A NexusOperationFailureInfo wrapping an ApplicationFailureInfo. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Failure details. A NexusOperationFailureInfo wrapping an ApplicationFailureInfo. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Failure details. A NexusOperationFailureInfo wrapping an ApplicationFailureInfo. + sig { void } + def clear_failure + end + + # The request ID allocated at schedule time. + sig { returns(String) } + def request_id + end + + # The request ID allocated at schedule time. + sig { params(value: String).void } + def request_id=(value) + end + + # The request ID allocated at schedule time. + sig { void } + def clear_request_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::History::V1::NexusOperationFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationFailedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Nexus operation timed out. +class Temporalio::Api::History::V1::NexusOperationTimedOutEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + request_id: T.nilable(String) + ).void + end + def initialize( + scheduled_event_id: 0, + failure: nil, + request_id: "" + ) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { returns(Integer) } + def scheduled_event_id + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { void } + def clear_scheduled_event_id + end + + # Failure details. A NexusOperationFailureInfo wrapping a CanceledFailureInfo. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Failure details. A NexusOperationFailureInfo wrapping a CanceledFailureInfo. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Failure details. A NexusOperationFailureInfo wrapping a CanceledFailureInfo. + sig { void } + def clear_failure + end + + # The request ID allocated at schedule time. + sig { returns(String) } + def request_id + end + + # The request ID allocated at schedule time. + sig { params(value: String).void } + def request_id=(value) + end + + # The request ID allocated at schedule time. + sig { void } + def clear_request_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::History::V1::NexusOperationTimedOutEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationTimedOutEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationTimedOutEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationTimedOutEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Nexus operation completed as canceled. May or may not have been due to a cancellation request by the workflow. +class Temporalio::Api::History::V1::NexusOperationCanceledEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + request_id: T.nilable(String) + ).void + end + def initialize( + scheduled_event_id: 0, + failure: nil, + request_id: "" + ) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { returns(Integer) } + def scheduled_event_id + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The ID of the `NEXUS_OPERATION_SCHEDULED` event. Uniquely identifies this operation. + sig { void } + def clear_scheduled_event_id + end + + # Cancellation details. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Cancellation details. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Cancellation details. + sig { void } + def clear_failure + end + + # The request ID allocated at schedule time. + sig { returns(String) } + def request_id + end + + # The request ID allocated at schedule time. + sig { params(value: String).void } + def request_id=(value) + end + + # The request ID allocated at schedule time. + sig { void } + def clear_request_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::History::V1::NexusOperationCanceledEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCanceledEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationCanceledEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCanceledEventAttributes, 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::History::V1::NexusOperationCancelRequestedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scheduled_event_id: T.nilable(Integer), + workflow_task_completed_event_id: T.nilable(Integer) + ).void + end + def initialize( + scheduled_event_id: 0, + workflow_task_completed_event_id: 0 + ) + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { void } + def clear_scheduled_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { void } + def clear_workflow_task_completed_event_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::History::V1::NexusOperationCancelRequestedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCancelRequestedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationCancelRequestedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCancelRequestedEventAttributes, 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::History::V1::NexusOperationCancelRequestCompletedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + requested_event_id: T.nilable(Integer), + workflow_task_completed_event_id: T.nilable(Integer), + scheduled_event_id: T.nilable(Integer) + ).void + end + def initialize( + requested_event_id: 0, + workflow_task_completed_event_id: 0, + scheduled_event_id: 0 + ) + end + + # The ID of the `NEXUS_OPERATION_CANCEL_REQUESTED` event. + sig { returns(Integer) } + def requested_event_id + end + + # The ID of the `NEXUS_OPERATION_CANCEL_REQUESTED` event. + sig { params(value: Integer).void } + def requested_event_id=(value) + end + + # The ID of the `NEXUS_OPERATION_CANCEL_REQUESTED` event. + sig { void } + def clear_requested_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { void } + def clear_workflow_task_completed_event_id + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { void } + def clear_scheduled_event_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::History::V1::NexusOperationCancelRequestCompletedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCancelRequestCompletedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationCancelRequestCompletedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCancelRequestCompletedEventAttributes, 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::History::V1::NexusOperationCancelRequestFailedEventAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + requested_event_id: T.nilable(Integer), + workflow_task_completed_event_id: T.nilable(Integer), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + scheduled_event_id: T.nilable(Integer) + ).void + end + def initialize( + requested_event_id: 0, + workflow_task_completed_event_id: 0, + failure: nil, + scheduled_event_id: 0 + ) + end + + # The ID of the `NEXUS_OPERATION_CANCEL_REQUESTED` event. + sig { returns(Integer) } + def requested_event_id + end + + # The ID of the `NEXUS_OPERATION_CANCEL_REQUESTED` event. + sig { params(value: Integer).void } + def requested_event_id=(value) + end + + # The ID of the `NEXUS_OPERATION_CANCEL_REQUESTED` event. + sig { void } + def clear_requested_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { returns(Integer) } + def workflow_task_completed_event_id + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { params(value: Integer).void } + def workflow_task_completed_event_id=(value) + end + + # The `WORKFLOW_TASK_COMPLETED` event that the corresponding RequestCancelNexusOperation command was reported +# with. + sig { void } + def clear_workflow_task_completed_event_id + end + + # Failure details. A NexusOperationFailureInfo wrapping a CanceledFailureInfo. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Failure details. A NexusOperationFailureInfo wrapping a CanceledFailureInfo. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Failure details. A NexusOperationFailureInfo wrapping a CanceledFailureInfo. + sig { void } + def clear_failure + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { returns(Integer) } + def scheduled_event_id + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The id of the `NEXUS_OPERATION_SCHEDULED` event this cancel request corresponds to. + sig { void } + def clear_scheduled_event_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::History::V1::NexusOperationCancelRequestFailedEventAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCancelRequestFailedEventAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::NexusOperationCancelRequestFailedEventAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::NexusOperationCancelRequestFailedEventAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# History events are the method by which Temporal SDKs advance (or recreate) workflow state. +# See the `EventType` enum for more info about what each event is for. +class Temporalio::Api::History::V1::HistoryEvent + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + event_id: T.nilable(Integer), + event_time: T.nilable(Google::Protobuf::Timestamp), + event_type: T.nilable(T.any(Symbol, String, Integer)), + version: T.nilable(Integer), + task_id: T.nilable(Integer), + worker_may_ignore: T.nilable(T::Boolean), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]), + principal: T.nilable(Temporalio::Api::Common::V1::Principal), + workflow_execution_started_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionStartedEventAttributes), + workflow_execution_completed_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCompletedEventAttributes), + workflow_execution_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionFailedEventAttributes), + workflow_execution_timed_out_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTimedOutEventAttributes), + workflow_task_scheduled_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowTaskScheduledEventAttributes), + workflow_task_started_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowTaskStartedEventAttributes), + workflow_task_completed_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowTaskCompletedEventAttributes), + workflow_task_timed_out_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowTaskTimedOutEventAttributes), + workflow_task_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowTaskFailedEventAttributes), + activity_task_scheduled_event_attributes: T.nilable(Temporalio::Api::History::V1::ActivityTaskScheduledEventAttributes), + activity_task_started_event_attributes: T.nilable(Temporalio::Api::History::V1::ActivityTaskStartedEventAttributes), + activity_task_completed_event_attributes: T.nilable(Temporalio::Api::History::V1::ActivityTaskCompletedEventAttributes), + activity_task_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::ActivityTaskFailedEventAttributes), + activity_task_timed_out_event_attributes: T.nilable(Temporalio::Api::History::V1::ActivityTaskTimedOutEventAttributes), + timer_started_event_attributes: T.nilable(Temporalio::Api::History::V1::TimerStartedEventAttributes), + timer_fired_event_attributes: T.nilable(Temporalio::Api::History::V1::TimerFiredEventAttributes), + activity_task_cancel_requested_event_attributes: T.nilable(Temporalio::Api::History::V1::ActivityTaskCancelRequestedEventAttributes), + activity_task_canceled_event_attributes: T.nilable(Temporalio::Api::History::V1::ActivityTaskCanceledEventAttributes), + timer_canceled_event_attributes: T.nilable(Temporalio::Api::History::V1::TimerCanceledEventAttributes), + marker_recorded_event_attributes: T.nilable(Temporalio::Api::History::V1::MarkerRecordedEventAttributes), + workflow_execution_signaled_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionSignaledEventAttributes), + workflow_execution_terminated_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTerminatedEventAttributes), + workflow_execution_cancel_requested_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCancelRequestedEventAttributes), + workflow_execution_canceled_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCanceledEventAttributes), + request_cancel_external_workflow_execution_initiated_event_attributes: T.nilable(Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes), + request_cancel_external_workflow_execution_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionFailedEventAttributes), + external_workflow_execution_cancel_requested_event_attributes: T.nilable(Temporalio::Api::History::V1::ExternalWorkflowExecutionCancelRequestedEventAttributes), + workflow_execution_continued_as_new_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionContinuedAsNewEventAttributes), + start_child_workflow_execution_initiated_event_attributes: T.nilable(Temporalio::Api::History::V1::StartChildWorkflowExecutionInitiatedEventAttributes), + start_child_workflow_execution_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::StartChildWorkflowExecutionFailedEventAttributes), + child_workflow_execution_started_event_attributes: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionStartedEventAttributes), + child_workflow_execution_completed_event_attributes: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionCompletedEventAttributes), + child_workflow_execution_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionFailedEventAttributes), + child_workflow_execution_canceled_event_attributes: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionCanceledEventAttributes), + child_workflow_execution_timed_out_event_attributes: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionTimedOutEventAttributes), + child_workflow_execution_terminated_event_attributes: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionTerminatedEventAttributes), + signal_external_workflow_execution_initiated_event_attributes: T.nilable(Temporalio::Api::History::V1::SignalExternalWorkflowExecutionInitiatedEventAttributes), + signal_external_workflow_execution_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::SignalExternalWorkflowExecutionFailedEventAttributes), + external_workflow_execution_signaled_event_attributes: T.nilable(Temporalio::Api::History::V1::ExternalWorkflowExecutionSignaledEventAttributes), + upsert_workflow_search_attributes_event_attributes: T.nilable(Temporalio::Api::History::V1::UpsertWorkflowSearchAttributesEventAttributes), + workflow_execution_update_accepted_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateAcceptedEventAttributes), + workflow_execution_update_rejected_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateRejectedEventAttributes), + workflow_execution_update_completed_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateCompletedEventAttributes), + workflow_properties_modified_externally_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowPropertiesModifiedExternallyEventAttributes), + activity_properties_modified_externally_event_attributes: T.nilable(Temporalio::Api::History::V1::ActivityPropertiesModifiedExternallyEventAttributes), + workflow_properties_modified_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowPropertiesModifiedEventAttributes), + workflow_execution_update_admitted_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateAdmittedEventAttributes), + nexus_operation_scheduled_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationScheduledEventAttributes), + nexus_operation_started_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationStartedEventAttributes), + nexus_operation_completed_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationCompletedEventAttributes), + nexus_operation_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationFailedEventAttributes), + nexus_operation_canceled_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationCanceledEventAttributes), + nexus_operation_timed_out_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationTimedOutEventAttributes), + nexus_operation_cancel_requested_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestedEventAttributes), + workflow_execution_options_updated_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionOptionsUpdatedEventAttributes), + nexus_operation_cancel_request_completed_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestCompletedEventAttributes), + nexus_operation_cancel_request_failed_event_attributes: T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestFailedEventAttributes), + workflow_execution_paused_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionPausedEventAttributes), + workflow_execution_unpaused_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUnpausedEventAttributes), + workflow_execution_time_skipping_transitioned_event_attributes: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTimeSkippingTransitionedEventAttributes) + ).void + end + def initialize( + event_id: 0, + event_time: nil, + event_type: :EVENT_TYPE_UNSPECIFIED, + version: 0, + task_id: 0, + worker_may_ignore: false, + user_metadata: nil, + links: [], + principal: nil, + workflow_execution_started_event_attributes: nil, + workflow_execution_completed_event_attributes: nil, + workflow_execution_failed_event_attributes: nil, + workflow_execution_timed_out_event_attributes: nil, + workflow_task_scheduled_event_attributes: nil, + workflow_task_started_event_attributes: nil, + workflow_task_completed_event_attributes: nil, + workflow_task_timed_out_event_attributes: nil, + workflow_task_failed_event_attributes: nil, + activity_task_scheduled_event_attributes: nil, + activity_task_started_event_attributes: nil, + activity_task_completed_event_attributes: nil, + activity_task_failed_event_attributes: nil, + activity_task_timed_out_event_attributes: nil, + timer_started_event_attributes: nil, + timer_fired_event_attributes: nil, + activity_task_cancel_requested_event_attributes: nil, + activity_task_canceled_event_attributes: nil, + timer_canceled_event_attributes: nil, + marker_recorded_event_attributes: nil, + workflow_execution_signaled_event_attributes: nil, + workflow_execution_terminated_event_attributes: nil, + workflow_execution_cancel_requested_event_attributes: nil, + workflow_execution_canceled_event_attributes: nil, + request_cancel_external_workflow_execution_initiated_event_attributes: nil, + request_cancel_external_workflow_execution_failed_event_attributes: nil, + external_workflow_execution_cancel_requested_event_attributes: nil, + workflow_execution_continued_as_new_event_attributes: nil, + start_child_workflow_execution_initiated_event_attributes: nil, + start_child_workflow_execution_failed_event_attributes: nil, + child_workflow_execution_started_event_attributes: nil, + child_workflow_execution_completed_event_attributes: nil, + child_workflow_execution_failed_event_attributes: nil, + child_workflow_execution_canceled_event_attributes: nil, + child_workflow_execution_timed_out_event_attributes: nil, + child_workflow_execution_terminated_event_attributes: nil, + signal_external_workflow_execution_initiated_event_attributes: nil, + signal_external_workflow_execution_failed_event_attributes: nil, + external_workflow_execution_signaled_event_attributes: nil, + upsert_workflow_search_attributes_event_attributes: nil, + workflow_execution_update_accepted_event_attributes: nil, + workflow_execution_update_rejected_event_attributes: nil, + workflow_execution_update_completed_event_attributes: nil, + workflow_properties_modified_externally_event_attributes: nil, + activity_properties_modified_externally_event_attributes: nil, + workflow_properties_modified_event_attributes: nil, + workflow_execution_update_admitted_event_attributes: nil, + nexus_operation_scheduled_event_attributes: nil, + nexus_operation_started_event_attributes: nil, + nexus_operation_completed_event_attributes: nil, + nexus_operation_failed_event_attributes: nil, + nexus_operation_canceled_event_attributes: nil, + nexus_operation_timed_out_event_attributes: nil, + nexus_operation_cancel_requested_event_attributes: nil, + workflow_execution_options_updated_event_attributes: nil, + nexus_operation_cancel_request_completed_event_attributes: nil, + nexus_operation_cancel_request_failed_event_attributes: nil, + workflow_execution_paused_event_attributes: nil, + workflow_execution_unpaused_event_attributes: nil, + workflow_execution_time_skipping_transitioned_event_attributes: nil + ) + end + + # Monotonically increasing event number, starts at 1. + sig { returns(Integer) } + def event_id + end + + # Monotonically increasing event number, starts at 1. + sig { params(value: Integer).void } + def event_id=(value) + end + + # Monotonically increasing event number, starts at 1. + sig { void } + def clear_event_id + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def event_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def event_time=(value) + end + + sig { void } + def clear_event_time + end + + sig { returns(T.any(Symbol, Integer)) } + def event_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def event_type=(value) + end + + sig { void } + def clear_event_type + end + + # Failover version of the event, used by the server for multi-cluster replication and history +# versioning. SDKs generally ignore this field. + sig { returns(Integer) } + def version + end + + # Failover version of the event, used by the server for multi-cluster replication and history +# versioning. SDKs generally ignore this field. + sig { params(value: Integer).void } + def version=(value) + end + + # Failover version of the event, used by the server for multi-cluster replication and history +# versioning. SDKs generally ignore this field. + sig { void } + def clear_version + end + + # Identifier used by the service to order replication and transfer tasks associated with this +# event. SDKs generally ignore this field. + sig { returns(Integer) } + def task_id + end + + # Identifier used by the service to order replication and transfer tasks associated with this +# event. SDKs generally ignore this field. + sig { params(value: Integer).void } + def task_id=(value) + end + + # Identifier used by the service to order replication and transfer tasks associated with this +# event. SDKs generally ignore this field. + sig { void } + def clear_task_id + end + + # Set to true when the SDK may ignore the event as it does not impact workflow state or +# information in any way that the SDK need be concerned with. If an SDK encounters an event +# type which it does not understand, it must error unless this is true. If it is true, it's +# acceptable for the event type and/or attributes to be uninterpretable. + sig { returns(T::Boolean) } + def worker_may_ignore + end + + # Set to true when the SDK may ignore the event as it does not impact workflow state or +# information in any way that the SDK need be concerned with. If an SDK encounters an event +# type which it does not understand, it must error unless this is true. If it is true, it's +# acceptable for the event type and/or attributes to be uninterpretable. + sig { params(value: T::Boolean).void } + def worker_may_ignore=(value) + end + + # Set to true when the SDK may ignore the event as it does not impact workflow state or +# information in any way that the SDK need be concerned with. If an SDK encounters an event +# type which it does not understand, it must error unless this is true. If it is true, it's +# acceptable for the event type and/or attributes to be uninterpretable. + sig { void } + def clear_worker_may_ignore + end + + # Metadata on the event. This is often carried over from commands and client calls. Most events +# won't have this information, and how this information is used is dependent upon the interface +# that reads it. +# +# Current well-known uses: +# * workflow_execution_started_event_attributes - summary and details from start workflow. +# * timer_started_event_attributes - summary represents an identifier for the timer for use by +# user interfaces. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata on the event. This is often carried over from commands and client calls. Most events +# won't have this information, and how this information is used is dependent upon the interface +# that reads it. +# +# Current well-known uses: +# * workflow_execution_started_event_attributes - summary and details from start workflow. +# * timer_started_event_attributes - summary represents an identifier for the timer for use by +# user interfaces. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata on the event. This is often carried over from commands and client calls. Most events +# won't have this information, and how this information is used is dependent upon the interface +# that reads it. +# +# Current well-known uses: +# * workflow_execution_started_event_attributes - summary and details from start workflow. +# * timer_started_event_attributes - summary represents an identifier for the timer for use by +# user interfaces. + sig { void } + def clear_user_metadata + end + + # Links to related entities, such as the entity that started this event's workflow. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to related entities, such as the entity that started this event's workflow. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to related entities, such as the entity that started this event's workflow. + sig { void } + def clear_links + end + + # Server-computed authenticated caller identity associated with this event. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Principal)) } + def principal + end + + # Server-computed authenticated caller identity associated with this event. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Principal)).void } + def principal=(value) + end + + # Server-computed authenticated caller identity associated with this event. + sig { void } + def clear_principal + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionStartedEventAttributes)) } + def workflow_execution_started_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionStartedEventAttributes)).void } + def workflow_execution_started_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_started_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCompletedEventAttributes)) } + def workflow_execution_completed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCompletedEventAttributes)).void } + def workflow_execution_completed_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_completed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionFailedEventAttributes)) } + def workflow_execution_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionFailedEventAttributes)).void } + def workflow_execution_failed_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTimedOutEventAttributes)) } + def workflow_execution_timed_out_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTimedOutEventAttributes)).void } + def workflow_execution_timed_out_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_timed_out_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowTaskScheduledEventAttributes)) } + def workflow_task_scheduled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowTaskScheduledEventAttributes)).void } + def workflow_task_scheduled_event_attributes=(value) + end + + sig { void } + def clear_workflow_task_scheduled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowTaskStartedEventAttributes)) } + def workflow_task_started_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowTaskStartedEventAttributes)).void } + def workflow_task_started_event_attributes=(value) + end + + sig { void } + def clear_workflow_task_started_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowTaskCompletedEventAttributes)) } + def workflow_task_completed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowTaskCompletedEventAttributes)).void } + def workflow_task_completed_event_attributes=(value) + end + + sig { void } + def clear_workflow_task_completed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowTaskTimedOutEventAttributes)) } + def workflow_task_timed_out_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowTaskTimedOutEventAttributes)).void } + def workflow_task_timed_out_event_attributes=(value) + end + + sig { void } + def clear_workflow_task_timed_out_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowTaskFailedEventAttributes)) } + def workflow_task_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowTaskFailedEventAttributes)).void } + def workflow_task_failed_event_attributes=(value) + end + + sig { void } + def clear_workflow_task_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ActivityTaskScheduledEventAttributes)) } + def activity_task_scheduled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ActivityTaskScheduledEventAttributes)).void } + def activity_task_scheduled_event_attributes=(value) + end + + sig { void } + def clear_activity_task_scheduled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ActivityTaskStartedEventAttributes)) } + def activity_task_started_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ActivityTaskStartedEventAttributes)).void } + def activity_task_started_event_attributes=(value) + end + + sig { void } + def clear_activity_task_started_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ActivityTaskCompletedEventAttributes)) } + def activity_task_completed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ActivityTaskCompletedEventAttributes)).void } + def activity_task_completed_event_attributes=(value) + end + + sig { void } + def clear_activity_task_completed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ActivityTaskFailedEventAttributes)) } + def activity_task_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ActivityTaskFailedEventAttributes)).void } + def activity_task_failed_event_attributes=(value) + end + + sig { void } + def clear_activity_task_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ActivityTaskTimedOutEventAttributes)) } + def activity_task_timed_out_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ActivityTaskTimedOutEventAttributes)).void } + def activity_task_timed_out_event_attributes=(value) + end + + sig { void } + def clear_activity_task_timed_out_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::TimerStartedEventAttributes)) } + def timer_started_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::TimerStartedEventAttributes)).void } + def timer_started_event_attributes=(value) + end + + sig { void } + def clear_timer_started_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::TimerFiredEventAttributes)) } + def timer_fired_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::TimerFiredEventAttributes)).void } + def timer_fired_event_attributes=(value) + end + + sig { void } + def clear_timer_fired_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ActivityTaskCancelRequestedEventAttributes)) } + def activity_task_cancel_requested_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ActivityTaskCancelRequestedEventAttributes)).void } + def activity_task_cancel_requested_event_attributes=(value) + end + + sig { void } + def clear_activity_task_cancel_requested_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ActivityTaskCanceledEventAttributes)) } + def activity_task_canceled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ActivityTaskCanceledEventAttributes)).void } + def activity_task_canceled_event_attributes=(value) + end + + sig { void } + def clear_activity_task_canceled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::TimerCanceledEventAttributes)) } + def timer_canceled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::TimerCanceledEventAttributes)).void } + def timer_canceled_event_attributes=(value) + end + + sig { void } + def clear_timer_canceled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::MarkerRecordedEventAttributes)) } + def marker_recorded_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::MarkerRecordedEventAttributes)).void } + def marker_recorded_event_attributes=(value) + end + + sig { void } + def clear_marker_recorded_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionSignaledEventAttributes)) } + def workflow_execution_signaled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionSignaledEventAttributes)).void } + def workflow_execution_signaled_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_signaled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTerminatedEventAttributes)) } + def workflow_execution_terminated_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTerminatedEventAttributes)).void } + def workflow_execution_terminated_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_terminated_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCancelRequestedEventAttributes)) } + def workflow_execution_cancel_requested_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCancelRequestedEventAttributes)).void } + def workflow_execution_cancel_requested_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_cancel_requested_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCanceledEventAttributes)) } + def workflow_execution_canceled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionCanceledEventAttributes)).void } + def workflow_execution_canceled_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_canceled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes)) } + def request_cancel_external_workflow_execution_initiated_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes)).void } + def request_cancel_external_workflow_execution_initiated_event_attributes=(value) + end + + sig { void } + def clear_request_cancel_external_workflow_execution_initiated_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionFailedEventAttributes)) } + def request_cancel_external_workflow_execution_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::RequestCancelExternalWorkflowExecutionFailedEventAttributes)).void } + def request_cancel_external_workflow_execution_failed_event_attributes=(value) + end + + sig { void } + def clear_request_cancel_external_workflow_execution_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ExternalWorkflowExecutionCancelRequestedEventAttributes)) } + def external_workflow_execution_cancel_requested_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ExternalWorkflowExecutionCancelRequestedEventAttributes)).void } + def external_workflow_execution_cancel_requested_event_attributes=(value) + end + + sig { void } + def clear_external_workflow_execution_cancel_requested_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionContinuedAsNewEventAttributes)) } + def workflow_execution_continued_as_new_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionContinuedAsNewEventAttributes)).void } + def workflow_execution_continued_as_new_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_continued_as_new_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::StartChildWorkflowExecutionInitiatedEventAttributes)) } + def start_child_workflow_execution_initiated_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::StartChildWorkflowExecutionInitiatedEventAttributes)).void } + def start_child_workflow_execution_initiated_event_attributes=(value) + end + + sig { void } + def clear_start_child_workflow_execution_initiated_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::StartChildWorkflowExecutionFailedEventAttributes)) } + def start_child_workflow_execution_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::StartChildWorkflowExecutionFailedEventAttributes)).void } + def start_child_workflow_execution_failed_event_attributes=(value) + end + + sig { void } + def clear_start_child_workflow_execution_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionStartedEventAttributes)) } + def child_workflow_execution_started_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionStartedEventAttributes)).void } + def child_workflow_execution_started_event_attributes=(value) + end + + sig { void } + def clear_child_workflow_execution_started_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionCompletedEventAttributes)) } + def child_workflow_execution_completed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionCompletedEventAttributes)).void } + def child_workflow_execution_completed_event_attributes=(value) + end + + sig { void } + def clear_child_workflow_execution_completed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionFailedEventAttributes)) } + def child_workflow_execution_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionFailedEventAttributes)).void } + def child_workflow_execution_failed_event_attributes=(value) + end + + sig { void } + def clear_child_workflow_execution_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionCanceledEventAttributes)) } + def child_workflow_execution_canceled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionCanceledEventAttributes)).void } + def child_workflow_execution_canceled_event_attributes=(value) + end + + sig { void } + def clear_child_workflow_execution_canceled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionTimedOutEventAttributes)) } + def child_workflow_execution_timed_out_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionTimedOutEventAttributes)).void } + def child_workflow_execution_timed_out_event_attributes=(value) + end + + sig { void } + def clear_child_workflow_execution_timed_out_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionTerminatedEventAttributes)) } + def child_workflow_execution_terminated_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ChildWorkflowExecutionTerminatedEventAttributes)).void } + def child_workflow_execution_terminated_event_attributes=(value) + end + + sig { void } + def clear_child_workflow_execution_terminated_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::SignalExternalWorkflowExecutionInitiatedEventAttributes)) } + def signal_external_workflow_execution_initiated_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::SignalExternalWorkflowExecutionInitiatedEventAttributes)).void } + def signal_external_workflow_execution_initiated_event_attributes=(value) + end + + sig { void } + def clear_signal_external_workflow_execution_initiated_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::SignalExternalWorkflowExecutionFailedEventAttributes)) } + def signal_external_workflow_execution_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::SignalExternalWorkflowExecutionFailedEventAttributes)).void } + def signal_external_workflow_execution_failed_event_attributes=(value) + end + + sig { void } + def clear_signal_external_workflow_execution_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ExternalWorkflowExecutionSignaledEventAttributes)) } + def external_workflow_execution_signaled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ExternalWorkflowExecutionSignaledEventAttributes)).void } + def external_workflow_execution_signaled_event_attributes=(value) + end + + sig { void } + def clear_external_workflow_execution_signaled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::UpsertWorkflowSearchAttributesEventAttributes)) } + def upsert_workflow_search_attributes_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::UpsertWorkflowSearchAttributesEventAttributes)).void } + def upsert_workflow_search_attributes_event_attributes=(value) + end + + sig { void } + def clear_upsert_workflow_search_attributes_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateAcceptedEventAttributes)) } + def workflow_execution_update_accepted_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateAcceptedEventAttributes)).void } + def workflow_execution_update_accepted_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_update_accepted_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateRejectedEventAttributes)) } + def workflow_execution_update_rejected_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateRejectedEventAttributes)).void } + def workflow_execution_update_rejected_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_update_rejected_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateCompletedEventAttributes)) } + def workflow_execution_update_completed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateCompletedEventAttributes)).void } + def workflow_execution_update_completed_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_update_completed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowPropertiesModifiedExternallyEventAttributes)) } + def workflow_properties_modified_externally_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowPropertiesModifiedExternallyEventAttributes)).void } + def workflow_properties_modified_externally_event_attributes=(value) + end + + sig { void } + def clear_workflow_properties_modified_externally_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::ActivityPropertiesModifiedExternallyEventAttributes)) } + def activity_properties_modified_externally_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::ActivityPropertiesModifiedExternallyEventAttributes)).void } + def activity_properties_modified_externally_event_attributes=(value) + end + + sig { void } + def clear_activity_properties_modified_externally_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowPropertiesModifiedEventAttributes)) } + def workflow_properties_modified_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowPropertiesModifiedEventAttributes)).void } + def workflow_properties_modified_event_attributes=(value) + end + + sig { void } + def clear_workflow_properties_modified_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateAdmittedEventAttributes)) } + def workflow_execution_update_admitted_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUpdateAdmittedEventAttributes)).void } + def workflow_execution_update_admitted_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_update_admitted_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationScheduledEventAttributes)) } + def nexus_operation_scheduled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationScheduledEventAttributes)).void } + def nexus_operation_scheduled_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_scheduled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationStartedEventAttributes)) } + def nexus_operation_started_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationStartedEventAttributes)).void } + def nexus_operation_started_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_started_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationCompletedEventAttributes)) } + def nexus_operation_completed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationCompletedEventAttributes)).void } + def nexus_operation_completed_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_completed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationFailedEventAttributes)) } + def nexus_operation_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationFailedEventAttributes)).void } + def nexus_operation_failed_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationCanceledEventAttributes)) } + def nexus_operation_canceled_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationCanceledEventAttributes)).void } + def nexus_operation_canceled_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_canceled_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationTimedOutEventAttributes)) } + def nexus_operation_timed_out_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationTimedOutEventAttributes)).void } + def nexus_operation_timed_out_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_timed_out_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestedEventAttributes)) } + def nexus_operation_cancel_requested_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestedEventAttributes)).void } + def nexus_operation_cancel_requested_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_cancel_requested_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionOptionsUpdatedEventAttributes)) } + def workflow_execution_options_updated_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionOptionsUpdatedEventAttributes)).void } + def workflow_execution_options_updated_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_options_updated_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestCompletedEventAttributes)) } + def nexus_operation_cancel_request_completed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestCompletedEventAttributes)).void } + def nexus_operation_cancel_request_completed_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_cancel_request_completed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestFailedEventAttributes)) } + def nexus_operation_cancel_request_failed_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::NexusOperationCancelRequestFailedEventAttributes)).void } + def nexus_operation_cancel_request_failed_event_attributes=(value) + end + + sig { void } + def clear_nexus_operation_cancel_request_failed_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionPausedEventAttributes)) } + def workflow_execution_paused_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionPausedEventAttributes)).void } + def workflow_execution_paused_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_paused_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUnpausedEventAttributes)) } + def workflow_execution_unpaused_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionUnpausedEventAttributes)).void } + def workflow_execution_unpaused_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_unpaused_event_attributes + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTimeSkippingTransitionedEventAttributes)) } + def workflow_execution_time_skipping_transitioned_event_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::WorkflowExecutionTimeSkippingTransitionedEventAttributes)).void } + def workflow_execution_time_skipping_transitioned_event_attributes=(value) + end + + sig { void } + def clear_workflow_execution_time_skipping_transitioned_event_attributes + end + + sig { returns(T.nilable(Symbol)) } + def attributes + 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::History::V1::HistoryEvent) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::HistoryEvent).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::HistoryEvent) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::HistoryEvent, 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::History::V1::History + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + events: T.nilable(T::Array[T.nilable(Temporalio::Api::History::V1::HistoryEvent)]) + ).void + end + def initialize( + events: [] + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::History::V1::HistoryEvent)]) } + def events + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def events=(value) + end + + sig { void } + def clear_events + 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::History::V1::History) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::History::V1::History).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::History::V1::History) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::History::V1::History, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/namespace/v1/message.rbi b/temporalio/rbi/temporalio/api/namespace/v1/message.rbi new file mode 100644 index 00000000..069eaba0 --- /dev/null +++ b/temporalio/rbi/temporalio/api/namespace/v1/message.rbi @@ -0,0 +1,976 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/namespace/v1/message.proto +# typed: strict + +class Temporalio::Api::Namespace::V1::NamespaceInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + description: T.nilable(String), + owner_email: T.nilable(String), + data: T.nilable(T::Hash[String, String]), + id: T.nilable(String), + capabilities: T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo::Capabilities), + limits: T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo::Limits), + supports_schedules: T.nilable(T::Boolean) + ).void + end + def initialize( + name: "", + state: :NAMESPACE_STATE_UNSPECIFIED, + description: "", + owner_email: "", + data: ::Google::Protobuf::Map.new(:string, :string), + id: "", + capabilities: nil, + limits: nil, + supports_schedules: false + ) + end + + sig { returns(String) } + def name + end + + sig { params(value: String).void } + def name=(value) + end + + sig { void } + def clear_name + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + end + + sig { returns(String) } + def description + end + + sig { params(value: String).void } + def description=(value) + end + + sig { void } + def clear_description + end + + sig { returns(String) } + def owner_email + end + + sig { params(value: String).void } + def owner_email=(value) + end + + sig { void } + def clear_owner_email + end + + # A key-value map for any customized purpose. + sig { returns(T::Hash[String, String]) } + def data + end + + # A key-value map for any customized purpose. + sig { params(value: ::Google::Protobuf::Map).void } + def data=(value) + end + + # A key-value map for any customized purpose. + sig { void } + def clear_data + end + + sig { returns(String) } + def id + end + + sig { params(value: String).void } + def id=(value) + end + + sig { void } + def clear_id + end + + # All capabilities the namespace supports. + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo::Capabilities)) } + def capabilities + end + + # All capabilities the namespace supports. + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo::Capabilities)).void } + def capabilities=(value) + end + + # All capabilities the namespace supports. + sig { void } + def clear_capabilities + end + + # Namespace configured limits + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo::Limits)) } + def limits + end + + # Namespace configured limits + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo::Limits)).void } + def limits=(value) + end + + # Namespace configured limits + sig { void } + def clear_limits + end + + # Whether scheduled workflows are supported on this namespace. This is only needed +# temporarily while the feature is experimental, so we can give it a high tag. + sig { returns(T::Boolean) } + def supports_schedules + end + + # Whether scheduled workflows are supported on this namespace. This is only needed +# temporarily while the feature is experimental, so we can give it a high tag. + sig { params(value: T::Boolean).void } + def supports_schedules=(value) + end + + # Whether scheduled workflows are supported on this namespace. This is only needed +# temporarily while the feature is experimental, so we can give it a high tag. + sig { void } + def clear_supports_schedules + 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::Namespace::V1::NamespaceInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Namespace::V1::NamespaceInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceInfo, 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::Namespace::V1::NamespaceConfig + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_execution_retention_ttl: T.nilable(Google::Protobuf::Duration), + bad_binaries: T.nilable(Temporalio::Api::Namespace::V1::BadBinaries), + history_archival_state: T.nilable(T.any(Symbol, String, Integer)), + history_archival_uri: T.nilable(String), + visibility_archival_state: T.nilable(T.any(Symbol, String, Integer)), + visibility_archival_uri: T.nilable(String), + custom_search_attribute_aliases: T.nilable(T::Hash[String, String]) + ).void + end + def initialize( + workflow_execution_retention_ttl: nil, + bad_binaries: nil, + history_archival_state: :ARCHIVAL_STATE_UNSPECIFIED, + history_archival_uri: "", + visibility_archival_state: :ARCHIVAL_STATE_UNSPECIFIED, + visibility_archival_uri: "", + custom_search_attribute_aliases: ::Google::Protobuf::Map.new(:string, :string) + ) + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_retention_ttl + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_retention_ttl=(value) + end + + sig { void } + def clear_workflow_execution_retention_ttl + end + + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::BadBinaries)) } + def bad_binaries + end + + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::BadBinaries)).void } + def bad_binaries=(value) + end + + sig { void } + def clear_bad_binaries + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { returns(T.any(Symbol, Integer)) } + def history_archival_state + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { params(value: T.any(Symbol, String, Integer)).void } + def history_archival_state=(value) + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { void } + def clear_history_archival_state + end + + sig { returns(String) } + def history_archival_uri + end + + sig { params(value: String).void } + def history_archival_uri=(value) + end + + sig { void } + def clear_history_archival_uri + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { returns(T.any(Symbol, Integer)) } + def visibility_archival_state + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { params(value: T.any(Symbol, String, Integer)).void } + def visibility_archival_state=(value) + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { void } + def clear_visibility_archival_state + end + + sig { returns(String) } + def visibility_archival_uri + end + + sig { params(value: String).void } + def visibility_archival_uri=(value) + end + + sig { void } + def clear_visibility_archival_uri + end + + # Map from field name to alias. + sig { returns(T::Hash[String, String]) } + def custom_search_attribute_aliases + end + + # Map from field name to alias. + sig { params(value: ::Google::Protobuf::Map).void } + def custom_search_attribute_aliases=(value) + end + + # Map from field name to alias. + sig { void } + def clear_custom_search_attribute_aliases + 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::Namespace::V1::NamespaceConfig) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceConfig).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Namespace::V1::NamespaceConfig) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceConfig, 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::Namespace::V1::BadBinaries + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + binaries: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Namespace::V1::BadBinaryInfo)]) + ).void + end + def initialize( + binaries: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Namespace::V1::BadBinaryInfo) + ) + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Namespace::V1::BadBinaryInfo)]) } + def binaries + end + + sig { params(value: ::Google::Protobuf::Map).void } + def binaries=(value) + end + + sig { void } + def clear_binaries + 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::Namespace::V1::BadBinaries) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::BadBinaries).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Namespace::V1::BadBinaries) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::BadBinaries, 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::Namespace::V1::BadBinaryInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + reason: T.nilable(String), + operator: T.nilable(String), + create_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + reason: "", + operator: "", + create_time: nil + ) + end + + sig { returns(String) } + def reason + end + + sig { params(value: String).void } + def reason=(value) + end + + sig { void } + def clear_reason + end + + sig { returns(String) } + def operator + end + + sig { params(value: String).void } + def operator=(value) + end + + sig { void } + def clear_operator + 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::Namespace::V1::BadBinaryInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::BadBinaryInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Namespace::V1::BadBinaryInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::BadBinaryInfo, 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::Namespace::V1::UpdateNamespaceInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + description: T.nilable(String), + owner_email: T.nilable(String), + data: T.nilable(T::Hash[String, String]), + state: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + description: "", + owner_email: "", + data: ::Google::Protobuf::Map.new(:string, :string), + state: :NAMESPACE_STATE_UNSPECIFIED + ) + end + + sig { returns(String) } + def description + end + + sig { params(value: String).void } + def description=(value) + end + + sig { void } + def clear_description + end + + sig { returns(String) } + def owner_email + end + + sig { params(value: String).void } + def owner_email=(value) + end + + sig { void } + def clear_owner_email + end + + # A key-value map for any customized purpose. +# If data already exists on the namespace, +# this will merge with the existing key values. + sig { returns(T::Hash[String, String]) } + def data + end + + # A key-value map for any customized purpose. +# If data already exists on the namespace, +# this will merge with the existing key values. + sig { params(value: ::Google::Protobuf::Map).void } + def data=(value) + end + + # A key-value map for any customized purpose. +# If data already exists on the namespace, +# this will merge with the existing key values. + sig { void } + def clear_data + end + + # New namespace state, server will reject if transition is not allowed. +# Allowed transitions are: +# Registered -> [ Deleted | Deprecated | Handover ] +# Handover -> [ Registered ] +# Default is NAMESPACE_STATE_UNSPECIFIED which is do not change state. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # New namespace state, server will reject if transition is not allowed. +# Allowed transitions are: +# Registered -> [ Deleted | Deprecated | Handover ] +# Handover -> [ Registered ] +# Default is NAMESPACE_STATE_UNSPECIFIED which is do not change state. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # New namespace state, server will reject if transition is not allowed. +# Allowed transitions are: +# Registered -> [ Deleted | Deprecated | Handover ] +# Handover -> [ Registered ] +# Default is NAMESPACE_STATE_UNSPECIFIED which is do not change state. + sig { void } + def clear_state + 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::Namespace::V1::UpdateNamespaceInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::UpdateNamespaceInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Namespace::V1::UpdateNamespaceInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::UpdateNamespaceInfo, 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::Namespace::V1::NamespaceFilter + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + include_deleted: T.nilable(T::Boolean) + ).void + end + def initialize( + include_deleted: false + ) + end + + # By default namespaces in NAMESPACE_STATE_DELETED state are not included. +# Setting include_deleted to true will include deleted namespaces. +# Note: Namespace is in NAMESPACE_STATE_DELETED state when it was deleted from the system but associated data is not deleted yet. + sig { returns(T::Boolean) } + def include_deleted + end + + # By default namespaces in NAMESPACE_STATE_DELETED state are not included. +# Setting include_deleted to true will include deleted namespaces. +# Note: Namespace is in NAMESPACE_STATE_DELETED state when it was deleted from the system but associated data is not deleted yet. + sig { params(value: T::Boolean).void } + def include_deleted=(value) + end + + # By default namespaces in NAMESPACE_STATE_DELETED state are not included. +# Setting include_deleted to true will include deleted namespaces. +# Note: Namespace is in NAMESPACE_STATE_DELETED state when it was deleted from the system but associated data is not deleted yet. + sig { void } + def clear_include_deleted + 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::Namespace::V1::NamespaceFilter) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceFilter).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Namespace::V1::NamespaceFilter) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceFilter, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Namespace capability details. Should contain what features are enabled in a namespace. +class Temporalio::Api::Namespace::V1::NamespaceInfo::Capabilities + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + eager_workflow_start: T.nilable(T::Boolean), + sync_update: T.nilable(T::Boolean), + async_update: T.nilable(T::Boolean), + worker_heartbeats: T.nilable(T::Boolean), + reported_problems_search_attribute: T.nilable(T::Boolean), + workflow_pause: T.nilable(T::Boolean), + standalone_activities: T.nilable(T::Boolean), + worker_poll_complete_on_shutdown: T.nilable(T::Boolean), + poller_autoscaling: T.nilable(T::Boolean) + ).void + end + def initialize( + eager_workflow_start: false, + sync_update: false, + async_update: false, + worker_heartbeats: false, + reported_problems_search_attribute: false, + workflow_pause: false, + standalone_activities: false, + worker_poll_complete_on_shutdown: false, + poller_autoscaling: false + ) + end + + # True if the namespace supports eager workflow start. + sig { returns(T::Boolean) } + def eager_workflow_start + end + + # True if the namespace supports eager workflow start. + sig { params(value: T::Boolean).void } + def eager_workflow_start=(value) + end + + # True if the namespace supports eager workflow start. + sig { void } + def clear_eager_workflow_start + end + + # True if the namespace supports sync update + sig { returns(T::Boolean) } + def sync_update + end + + # True if the namespace supports sync update + sig { params(value: T::Boolean).void } + def sync_update=(value) + end + + # True if the namespace supports sync update + sig { void } + def clear_sync_update + end + + # True if the namespace supports async update + sig { returns(T::Boolean) } + def async_update + end + + # True if the namespace supports async update + sig { params(value: T::Boolean).void } + def async_update=(value) + end + + # True if the namespace supports async update + sig { void } + def clear_async_update + end + + # True if the namespace supports worker heartbeats + sig { returns(T::Boolean) } + def worker_heartbeats + end + + # True if the namespace supports worker heartbeats + sig { params(value: T::Boolean).void } + def worker_heartbeats=(value) + end + + # True if the namespace supports worker heartbeats + sig { void } + def clear_worker_heartbeats + end + + # True if the namespace supports reported problems search attribute + sig { returns(T::Boolean) } + def reported_problems_search_attribute + end + + # True if the namespace supports reported problems search attribute + sig { params(value: T::Boolean).void } + def reported_problems_search_attribute=(value) + end + + # True if the namespace supports reported problems search attribute + sig { void } + def clear_reported_problems_search_attribute + end + + # True if the namespace supports pausing workflows + sig { returns(T::Boolean) } + def workflow_pause + end + + # True if the namespace supports pausing workflows + sig { params(value: T::Boolean).void } + def workflow_pause=(value) + end + + # True if the namespace supports pausing workflows + sig { void } + def clear_workflow_pause + end + + # True if the namespace supports standalone activities + sig { returns(T::Boolean) } + def standalone_activities + end + + # True if the namespace supports standalone activities + sig { params(value: T::Boolean).void } + def standalone_activities=(value) + end + + # True if the namespace supports standalone activities + sig { void } + def clear_standalone_activities + end + + # True if the namespace supports server-side completion of outstanding worker polls on shutdown. +# When enabled, the server will complete polls for workers that send WorkerInstanceKey in their +# poll requests and call ShutdownWorker with the same WorkerInstanceKey. The poll will return +# an empty response. When this flag is true, workers should allow polls to return gracefully +# rather than terminating any open polls on shutdown. + sig { returns(T::Boolean) } + def worker_poll_complete_on_shutdown + end + + # True if the namespace supports server-side completion of outstanding worker polls on shutdown. +# When enabled, the server will complete polls for workers that send WorkerInstanceKey in their +# poll requests and call ShutdownWorker with the same WorkerInstanceKey. The poll will return +# an empty response. When this flag is true, workers should allow polls to return gracefully +# rather than terminating any open polls on shutdown. + sig { params(value: T::Boolean).void } + def worker_poll_complete_on_shutdown=(value) + end + + # True if the namespace supports server-side completion of outstanding worker polls on shutdown. +# When enabled, the server will complete polls for workers that send WorkerInstanceKey in their +# poll requests and call ShutdownWorker with the same WorkerInstanceKey. The poll will return +# an empty response. When this flag is true, workers should allow polls to return gracefully +# rather than terminating any open polls on shutdown. + sig { void } + def clear_worker_poll_complete_on_shutdown + end + + # True if the namespace supports poller autoscaling + sig { returns(T::Boolean) } + def poller_autoscaling + end + + # True if the namespace supports poller autoscaling + sig { params(value: T::Boolean).void } + def poller_autoscaling=(value) + end + + # True if the namespace supports poller autoscaling + sig { void } + def clear_poller_autoscaling + 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::Namespace::V1::NamespaceInfo::Capabilities) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceInfo::Capabilities).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Namespace::V1::NamespaceInfo::Capabilities) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceInfo::Capabilities, 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::Namespace::V1::NamespaceInfo::Limits + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + blob_size_limit_error: T.nilable(Integer), + memo_size_limit_error: T.nilable(Integer) + ).void + end + def initialize( + blob_size_limit_error: 0, + memo_size_limit_error: 0 + ) + end + + # Maximum size in bytes for payload fields in workflow history events +# (e.g., workflow/activity inputs and results, failure details, signal payloads). +# When exceeded, the server will reject the operation with an error. + sig { returns(Integer) } + def blob_size_limit_error + end + + # Maximum size in bytes for payload fields in workflow history events +# (e.g., workflow/activity inputs and results, failure details, signal payloads). +# When exceeded, the server will reject the operation with an error. + sig { params(value: Integer).void } + def blob_size_limit_error=(value) + end + + # Maximum size in bytes for payload fields in workflow history events +# (e.g., workflow/activity inputs and results, failure details, signal payloads). +# When exceeded, the server will reject the operation with an error. + sig { void } + def clear_blob_size_limit_error + end + + # Maximum total memo size in bytes per workflow execution. + sig { returns(Integer) } + def memo_size_limit_error + end + + # Maximum total memo size in bytes per workflow execution. + sig { params(value: Integer).void } + def memo_size_limit_error=(value) + end + + # Maximum total memo size in bytes per workflow execution. + sig { void } + def clear_memo_size_limit_error + 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::Namespace::V1::NamespaceInfo::Limits) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceInfo::Limits).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Namespace::V1::NamespaceInfo::Limits) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Namespace::V1::NamespaceInfo::Limits, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/nexus/v1/message.rbi b/temporalio/rbi/temporalio/api/nexus/v1/message.rbi new file mode 100644 index 00000000..3f166226 --- /dev/null +++ b/temporalio/rbi/temporalio/api/nexus/v1/message.rbi @@ -0,0 +1,2746 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/nexus/v1/message.proto +# typed: strict + +# A general purpose failure message. +# See: https://github.com/nexus-rpc/api/blob/main/SPEC.md#failure +class Temporalio::Api::Nexus::V1::Failure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + message: T.nilable(String), + stack_trace: T.nilable(String), + metadata: T.nilable(T::Hash[String, String]), + details: T.nilable(String), + cause: T.nilable(Temporalio::Api::Nexus::V1::Failure) + ).void + end + def initialize( + message: "", + stack_trace: "", + metadata: ::Google::Protobuf::Map.new(:string, :string), + details: "", + cause: nil + ) + end + + sig { returns(String) } + def message + end + + sig { params(value: String).void } + def message=(value) + end + + sig { void } + def clear_message + end + + sig { returns(String) } + def stack_trace + end + + sig { params(value: String).void } + def stack_trace=(value) + end + + sig { void } + def clear_stack_trace + end + + sig { returns(T::Hash[String, String]) } + def metadata + end + + sig { params(value: ::Google::Protobuf::Map).void } + def metadata=(value) + end + + sig { void } + def clear_metadata + end + + # UTF-8 encoded JSON serializable details. + sig { returns(String) } + def details + end + + # UTF-8 encoded JSON serializable details. + sig { params(value: String).void } + def details=(value) + end + + # UTF-8 encoded JSON serializable details. + sig { void } + def clear_details + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Failure)) } + def cause + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Failure)).void } + def cause=(value) + end + + sig { void } + def clear_cause + 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::Nexus::V1::Failure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Failure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::Failure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Failure, 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::Nexus::V1::HandlerError + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + error_type: T.nilable(String), + failure: T.nilable(Temporalio::Api::Nexus::V1::Failure), + retry_behavior: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + error_type: "", + failure: nil, + retry_behavior: :NEXUS_HANDLER_ERROR_RETRY_BEHAVIOR_UNSPECIFIED + ) + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#predefined-handler-errors. + sig { returns(String) } + def error_type + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#predefined-handler-errors. + sig { params(value: String).void } + def error_type=(value) + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#predefined-handler-errors. + sig { void } + def clear_error_type + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + end + + # Retry behavior, defaults to the retry behavior of the error type as defined in the spec. + sig { returns(T.any(Symbol, Integer)) } + def retry_behavior + end + + # Retry behavior, defaults to the retry behavior of the error type as defined in the spec. + sig { params(value: T.any(Symbol, String, Integer)).void } + def retry_behavior=(value) + end + + # Retry behavior, defaults to the retry behavior of the error type as defined in the spec. + sig { void } + def clear_retry_behavior + 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::Nexus::V1::HandlerError) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::HandlerError).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::HandlerError) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::HandlerError, 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::Nexus::V1::UnsuccessfulOperationError + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + operation_state: T.nilable(String), + failure: T.nilable(Temporalio::Api::Nexus::V1::Failure) + ).void + end + def initialize( + operation_state: "", + failure: nil + ) + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#operationinfo. + sig { returns(String) } + def operation_state + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#operationinfo. + sig { params(value: String).void } + def operation_state=(value) + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#operationinfo. + sig { void } + def clear_operation_state + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Nexus::V1::UnsuccessfulOperationError) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::UnsuccessfulOperationError).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::UnsuccessfulOperationError) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::UnsuccessfulOperationError, 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::Nexus::V1::Link + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + url: T.nilable(String), + type: T.nilable(String) + ).void + end + def initialize( + url: "", + type: "" + ) + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#links. + sig { returns(String) } + def url + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#links. + sig { params(value: String).void } + def url=(value) + end + + # See https://github.com/nexus-rpc/api/blob/main/SPEC.md#links. + sig { void } + def clear_url + end + + sig { returns(String) } + def type + end + + sig { params(value: String).void } + def type=(value) + end + + sig { void } + def clear_type + 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::Nexus::V1::Link) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Link).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::Link) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Link, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A request to start an operation. +class Temporalio::Api::Nexus::V1::StartOperationRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service: T.nilable(String), + operation: T.nilable(String), + request_id: T.nilable(String), + callback: T.nilable(String), + payload: T.nilable(Temporalio::Api::Common::V1::Payload), + callback_header: T.nilable(T::Hash[String, String]), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Nexus::V1::Link)]) + ).void + end + def initialize( + service: "", + operation: "", + request_id: "", + callback: "", + payload: nil, + callback_header: ::Google::Protobuf::Map.new(:string, :string), + links: [] + ) + end + + # Name of service to start the operation in. + sig { returns(String) } + def service + end + + # Name of service to start the operation in. + sig { params(value: String).void } + def service=(value) + end + + # Name of service to start the operation in. + sig { void } + def clear_service + end + + # Type of operation to start. + sig { returns(String) } + def operation + end + + # Type of operation to start. + sig { params(value: String).void } + def operation=(value) + end + + # Type of operation to start. + sig { void } + def clear_operation + end + + # A request ID that can be used as an idempotentency key. + sig { returns(String) } + def request_id + end + + # A request ID that can be used as an idempotentency key. + sig { params(value: String).void } + def request_id=(value) + end + + # A request ID that can be used as an idempotentency key. + sig { void } + def clear_request_id + end + + # Callback URL to call upon completion if the started operation is async. + sig { returns(String) } + def callback + end + + # Callback URL to call upon completion if the started operation is async. + sig { params(value: String).void } + def callback=(value) + end + + # Callback URL to call upon completion if the started operation is async. + sig { void } + def clear_callback + end + + # Full request body from the incoming HTTP request. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def payload + end + + # Full request body from the incoming HTTP request. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def payload=(value) + end + + # Full request body from the incoming HTTP request. + sig { void } + def clear_payload + end + + # Header that is expected to be attached to the callback request when the operation completes. + sig { returns(T::Hash[String, String]) } + def callback_header + end + + # Header that is expected to be attached to the callback request when the operation completes. + sig { params(value: ::Google::Protobuf::Map).void } + def callback_header=(value) + end + + # Header that is expected to be attached to the callback request when the operation completes. + sig { void } + def clear_callback_header + end + + # Links contain caller information and can be attached to the operations started by the handler. + sig { returns(T::Array[T.nilable(Temporalio::Api::Nexus::V1::Link)]) } + def links + end + + # Links contain caller information and can be attached to the operations started by the handler. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links contain caller information and can be attached to the operations started by the handler. + sig { void } + def clear_links + 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::Nexus::V1::StartOperationRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::StartOperationRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::StartOperationRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::StartOperationRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A request to cancel an operation. +class Temporalio::Api::Nexus::V1::CancelOperationRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service: T.nilable(String), + operation: T.nilable(String), + operation_id: T.nilable(String), + operation_token: T.nilable(String) + ).void + end + def initialize( + service: "", + operation: "", + operation_id: "", + operation_token: "" + ) + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Type of operation to cancel. + sig { returns(String) } + def operation + end + + # Type of operation to cancel. + sig { params(value: String).void } + def operation=(value) + end + + # Type of operation to cancel. + sig { void } + def clear_operation + end + + # Operation ID as originally generated by a Handler. +# +# Deprecated. Renamed to operation_token. + sig { returns(String) } + def operation_id + end + + # Operation ID as originally generated by a Handler. +# +# Deprecated. Renamed to operation_token. + sig { params(value: String).void } + def operation_id=(value) + end + + # Operation ID as originally generated by a Handler. +# +# Deprecated. Renamed to operation_token. + sig { void } + def clear_operation_id + end + + # Operation token as originally generated by a Handler. + sig { returns(String) } + def operation_token + end + + # Operation token as originally generated by a Handler. + sig { params(value: String).void } + def operation_token=(value) + end + + # Operation token as originally generated by a Handler. + sig { void } + def clear_operation_token + 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::Nexus::V1::CancelOperationRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::CancelOperationRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::CancelOperationRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::CancelOperationRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A Nexus request. +class Temporalio::Api::Nexus::V1::Request + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + header: T.nilable(T::Hash[String, String]), + scheduled_time: T.nilable(Google::Protobuf::Timestamp), + capabilities: T.nilable(Temporalio::Api::Nexus::V1::Request::Capabilities), + start_operation: T.nilable(Temporalio::Api::Nexus::V1::StartOperationRequest), + cancel_operation: T.nilable(Temporalio::Api::Nexus::V1::CancelOperationRequest), + endpoint: T.nilable(String) + ).void + end + def initialize( + header: ::Google::Protobuf::Map.new(:string, :string), + scheduled_time: nil, + capabilities: nil, + start_operation: nil, + cancel_operation: nil, + endpoint: "" + ) + end + + # Headers extracted from the original request in the Temporal frontend. +# When using Nexus over HTTP, this includes the request's HTTP headers ignoring multiple values. + sig { returns(T::Hash[String, String]) } + def header + end + + # Headers extracted from the original request in the Temporal frontend. +# When using Nexus over HTTP, this includes the request's HTTP headers ignoring multiple values. + sig { params(value: ::Google::Protobuf::Map).void } + def header=(value) + end + + # Headers extracted from the original request in the Temporal frontend. +# When using Nexus over HTTP, this includes the request's HTTP headers ignoring multiple values. + sig { void } + def clear_header + end + + # The timestamp when the request was scheduled in the frontend. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def scheduled_time + end + + # The timestamp when the request was scheduled in the frontend. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def scheduled_time=(value) + end + + # The timestamp when the request was scheduled in the frontend. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { void } + def clear_scheduled_time + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Request::Capabilities)) } + def capabilities + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Request::Capabilities)).void } + def capabilities=(value) + end + + sig { void } + def clear_capabilities + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::StartOperationRequest)) } + def start_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::StartOperationRequest)).void } + def start_operation=(value) + end + + sig { void } + def clear_start_operation + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::CancelOperationRequest)) } + def cancel_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::CancelOperationRequest)).void } + def cancel_operation=(value) + end + + sig { void } + def clear_cancel_operation + end + + # The endpoint this request was addressed to before forwarding to the worker. +# Supported from server version 1.30.0. + sig { returns(String) } + def endpoint + end + + # The endpoint this request was addressed to before forwarding to the worker. +# Supported from server version 1.30.0. + sig { params(value: String).void } + def endpoint=(value) + end + + # The endpoint this request was addressed to before forwarding to the worker. +# Supported from server version 1.30.0. + sig { void } + def clear_endpoint + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Nexus::V1::Request) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Request).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::Request) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Request, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Response variant for StartOperationRequest. +class Temporalio::Api::Nexus::V1::StartOperationResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + sync_success: T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse::Sync), + async_success: T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse::Async), + operation_error: T.nilable(Temporalio::Api::Nexus::V1::UnsuccessfulOperationError), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + sync_success: nil, + async_success: nil, + operation_error: nil, + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse::Sync)) } + def sync_success + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse::Sync)).void } + def sync_success=(value) + end + + sig { void } + def clear_sync_success + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse::Async)) } + def async_success + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse::Async)).void } + def async_success=(value) + end + + sig { void } + def clear_async_success + end + + # The operation completed unsuccessfully (failed or canceled). +# Deprecated. Use the failure variant instead. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::UnsuccessfulOperationError)) } + def operation_error + end + + # The operation completed unsuccessfully (failed or canceled). +# Deprecated. Use the failure variant instead. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::UnsuccessfulOperationError)).void } + def operation_error=(value) + end + + # The operation completed unsuccessfully (failed or canceled). +# Deprecated. Use the failure variant instead. + sig { void } + def clear_operation_error + end + + # The operation completed unsuccessfully (failed or canceled). +# Failure object must contain an ApplicationFailureInfo or CanceledFailureInfo object. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The operation completed unsuccessfully (failed or canceled). +# Failure object must contain an ApplicationFailureInfo or CanceledFailureInfo object. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The operation completed unsuccessfully (failed or canceled). +# Failure object must contain an ApplicationFailureInfo or CanceledFailureInfo object. + sig { void } + def clear_failure + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Nexus::V1::StartOperationResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::StartOperationResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::StartOperationResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::StartOperationResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Response variant for CancelOperationRequest. +class Temporalio::Api::Nexus::V1::CancelOperationResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Nexus::V1::CancelOperationResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::CancelOperationResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::CancelOperationResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::CancelOperationResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A response indicating that the handler has successfully processed a request. +class Temporalio::Api::Nexus::V1::Response + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_operation: T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse), + cancel_operation: T.nilable(Temporalio::Api::Nexus::V1::CancelOperationResponse) + ).void + end + def initialize( + start_operation: nil, + cancel_operation: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse)) } + def start_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::StartOperationResponse)).void } + def start_operation=(value) + end + + sig { void } + def clear_start_operation + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::CancelOperationResponse)) } + def cancel_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::CancelOperationResponse)).void } + def cancel_operation=(value) + end + + sig { void } + def clear_cancel_operation + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Nexus::V1::Response) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Response).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::Response) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Response, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A cluster-global binding from an endpoint ID to a target for dispatching incoming Nexus requests. +class Temporalio::Api::Nexus::V1::Endpoint + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + version: T.nilable(Integer), + id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec), + created_time: T.nilable(Google::Protobuf::Timestamp), + last_modified_time: T.nilable(Google::Protobuf::Timestamp), + url_prefix: T.nilable(String) + ).void + end + def initialize( + version: 0, + id: "", + spec: nil, + created_time: nil, + last_modified_time: nil, + url_prefix: "" + ) + end + + # Data version for this endpoint, incremented for every update issued via the UpdateNexusEndpoint API. + sig { returns(Integer) } + def version + end + + # Data version for this endpoint, incremented for every update issued via the UpdateNexusEndpoint API. + sig { params(value: Integer).void } + def version=(value) + end + + # Data version for this endpoint, incremented for every update issued via the UpdateNexusEndpoint API. + sig { void } + def clear_version + end + + # Unique server-generated endpoint ID. + sig { returns(String) } + def id + end + + # Unique server-generated endpoint ID. + sig { params(value: String).void } + def id=(value) + end + + # Unique server-generated endpoint ID. + sig { void } + def clear_id + end + + # Spec for the endpoint. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec)) } + def spec + end + + # Spec for the endpoint. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec)).void } + def spec=(value) + end + + # Spec for the endpoint. + sig { void } + def clear_spec + end + + # The date and time when the endpoint was created. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def created_time + end + + # The date and time when the endpoint was created. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def created_time=(value) + end + + # The date and time when the endpoint was created. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { void } + def clear_created_time + end + + # The date and time when the endpoint was last modified. +# Will not be set if the endpoint has never been modified. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_modified_time + end + + # The date and time when the endpoint was last modified. +# Will not be set if the endpoint has never been modified. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_modified_time=(value) + end + + # The date and time when the endpoint was last modified. +# Will not be set if the endpoint has never been modified. +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { void } + def clear_last_modified_time + end + + # Server exposed URL prefix for invocation of operations on this endpoint. +# This doesn't include the protocol, hostname or port as the server does not know how it should be accessed +# publicly. The URL is stable in the face of endpoint renames. + sig { returns(String) } + def url_prefix + end + + # Server exposed URL prefix for invocation of operations on this endpoint. +# This doesn't include the protocol, hostname or port as the server does not know how it should be accessed +# publicly. The URL is stable in the face of endpoint renames. + sig { params(value: String).void } + def url_prefix=(value) + end + + # Server exposed URL prefix for invocation of operations on this endpoint. +# This doesn't include the protocol, hostname or port as the server does not know how it should be accessed +# publicly. The URL is stable in the face of endpoint renames. + sig { void } + def clear_url_prefix + 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::Nexus::V1::Endpoint) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Endpoint).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::Endpoint) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Endpoint, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Contains mutable fields for an Endpoint. +class Temporalio::Api::Nexus::V1::EndpointSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + description: T.nilable(Temporalio::Api::Common::V1::Payload), + target: T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget) + ).void + end + def initialize( + name: "", + description: nil, + target: nil + ) + end + + # Endpoint name, unique for this cluster. Must match `[a-zA-Z_][a-zA-Z0-9_]*`. +# Renaming an endpoint breaks all workflow callers that reference this endpoint, causing operations to fail. + sig { returns(String) } + def name + end + + # Endpoint name, unique for this cluster. Must match `[a-zA-Z_][a-zA-Z0-9_]*`. +# Renaming an endpoint breaks all workflow callers that reference this endpoint, causing operations to fail. + sig { params(value: String).void } + def name=(value) + end + + # Endpoint name, unique for this cluster. Must match `[a-zA-Z_][a-zA-Z0-9_]*`. +# Renaming an endpoint breaks all workflow callers that reference this endpoint, causing operations to fail. + sig { void } + def clear_name + end + + # Markdown description serialized as a single JSON string. +# If the Payload is encrypted, the UI and CLI may decrypt with the configured codec server endpoint. +# By default, the server enforces a limit of 20,000 bytes for this entire payload. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def description + end + + # Markdown description serialized as a single JSON string. +# If the Payload is encrypted, the UI and CLI may decrypt with the configured codec server endpoint. +# By default, the server enforces a limit of 20,000 bytes for this entire payload. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def description=(value) + end + + # Markdown description serialized as a single JSON string. +# If the Payload is encrypted, the UI and CLI may decrypt with the configured codec server endpoint. +# By default, the server enforces a limit of 20,000 bytes for this entire payload. + sig { void } + def clear_description + end + + # Target to route requests to. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget)) } + def target + end + + # Target to route requests to. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget)).void } + def target=(value) + end + + # Target to route requests to. + sig { void } + def clear_target + 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::Nexus::V1::EndpointSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::EndpointSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::EndpointSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::EndpointSpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Target to route requests to. +class Temporalio::Api::Nexus::V1::EndpointTarget + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker: T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget::Worker), + external: T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget::External) + ).void + end + def initialize( + worker: nil, + external: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget::Worker)) } + def worker + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget::Worker)).void } + def worker=(value) + end + + sig { void } + def clear_worker + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget::External)) } + def external + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::EndpointTarget::External)).void } + def external=(value) + end + + sig { void } + def clear_external + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Nexus::V1::EndpointTarget) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::EndpointTarget).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::EndpointTarget) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::EndpointTarget, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# NexusOperationExecutionCancellationInfo contains the state of a Nexus operation cancellation. +class Temporalio::Api::Nexus::V1::NexusOperationExecutionCancellationInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + requested_time: T.nilable(Google::Protobuf::Timestamp), + state: T.nilable(T.any(Symbol, String, Integer)), + attempt: T.nilable(Integer), + last_attempt_complete_time: T.nilable(Google::Protobuf::Timestamp), + last_attempt_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + next_attempt_schedule_time: T.nilable(Google::Protobuf::Timestamp), + blocked_reason: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + requested_time: nil, + state: :NEXUS_OPERATION_CANCELLATION_STATE_UNSPECIFIED, + attempt: 0, + last_attempt_complete_time: nil, + last_attempt_failure: nil, + next_attempt_schedule_time: nil, + blocked_reason: "", + reason: "" + ) + end + + # The time when cancellation was requested. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def requested_time + end + + # The time when cancellation was requested. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def requested_time=(value) + end + + # The time when cancellation was requested. + sig { void } + def clear_requested_time + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + end + + # The number of attempts made to deliver the cancel operation request. +# This number represents a minimum bound since the attempt is incremented after the request completes. + sig { returns(Integer) } + def attempt + end + + # The number of attempts made to deliver the cancel operation request. +# This number represents a minimum bound since the attempt is incremented after the request completes. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The number of attempts made to deliver the cancel operation request. +# This number represents a minimum bound since the attempt is incremented after the request completes. + sig { void } + def clear_attempt + end + + # The time when the last attempt completed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_attempt_complete_time + end + + # The time when the last attempt completed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_attempt_complete_time=(value) + end + + # The time when the last attempt completed. + sig { void } + def clear_last_attempt_complete_time + end + + # The last attempt's failure, if any. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_attempt_failure + end + + # The last attempt's failure, if any. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_attempt_failure=(value) + end + + # The last attempt's failure, if any. + sig { void } + def clear_last_attempt_failure + end + + # The time when the next attempt is scheduled. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def next_attempt_schedule_time + end + + # The time when the next attempt is scheduled. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def next_attempt_schedule_time=(value) + end + + # The time when the next attempt is scheduled. + sig { void } + def clear_next_attempt_schedule_time + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { returns(String) } + def blocked_reason + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { params(value: String).void } + def blocked_reason=(value) + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { void } + def clear_blocked_reason + end + + # A reason that may be specified in the CancelNexusOperationRequest. + sig { returns(String) } + def reason + end + + # A reason that may be specified in the CancelNexusOperationRequest. + sig { params(value: String).void } + def reason=(value) + end + + # A reason that may be specified in the CancelNexusOperationRequest. + sig { void } + def clear_reason + 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::Nexus::V1::NexusOperationExecutionCancellationInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::NexusOperationExecutionCancellationInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::NexusOperationExecutionCancellationInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::NexusOperationExecutionCancellationInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Full current state of a standalone Nexus operation, as of the time of the request. +class Temporalio::Api::Nexus::V1::NexusOperationExecutionInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + operation_id: T.nilable(String), + run_id: T.nilable(String), + endpoint: T.nilable(String), + service: T.nilable(String), + operation: T.nilable(String), + status: T.nilable(T.any(Symbol, String, Integer)), + state: T.nilable(T.any(Symbol, String, Integer)), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + attempt: T.nilable(Integer), + schedule_time: T.nilable(Google::Protobuf::Timestamp), + expiration_time: T.nilable(Google::Protobuf::Timestamp), + close_time: T.nilable(Google::Protobuf::Timestamp), + last_attempt_complete_time: T.nilable(Google::Protobuf::Timestamp), + last_attempt_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + next_attempt_schedule_time: T.nilable(Google::Protobuf::Timestamp), + execution_duration: T.nilable(Google::Protobuf::Duration), + cancellation_info: T.nilable(Temporalio::Api::Nexus::V1::NexusOperationExecutionCancellationInfo), + blocked_reason: T.nilable(String), + request_id: T.nilable(String), + operation_token: T.nilable(String), + state_transition_count: T.nilable(Integer), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + nexus_header: T.nilable(T::Hash[String, String]), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]), + identity: T.nilable(String) + ).void + end + def initialize( + operation_id: "", + run_id: "", + endpoint: "", + service: "", + operation: "", + status: :NEXUS_OPERATION_EXECUTION_STATUS_UNSPECIFIED, + state: :PENDING_NEXUS_OPERATION_STATE_UNSPECIFIED, + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + attempt: 0, + schedule_time: nil, + expiration_time: nil, + close_time: nil, + last_attempt_complete_time: nil, + last_attempt_failure: nil, + next_attempt_schedule_time: nil, + execution_duration: nil, + cancellation_info: nil, + blocked_reason: "", + request_id: "", + operation_token: "", + state_transition_count: 0, + search_attributes: nil, + nexus_header: ::Google::Protobuf::Map.new(:string, :string), + user_metadata: nil, + links: [], + identity: "" + ) + end + + # Unique identifier of this Nexus operation within its namespace along with run ID (below). + sig { returns(String) } + def operation_id + end + + # Unique identifier of this Nexus operation within its namespace along with run ID (below). + sig { params(value: String).void } + def operation_id=(value) + end + + # Unique identifier of this Nexus operation within its namespace along with run ID (below). + sig { void } + def clear_operation_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + # Endpoint name, resolved to a URL via the cluster's endpoint registry. + sig { returns(String) } + def endpoint + end + + # Endpoint name, resolved to a URL via the cluster's endpoint registry. + sig { params(value: String).void } + def endpoint=(value) + end + + # Endpoint name, resolved to a URL via the cluster's endpoint registry. + sig { void } + def clear_endpoint + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Operation name. + sig { returns(String) } + def operation + end + + # Operation name. + sig { params(value: String).void } + def operation=(value) + end + + # Operation name. + sig { void } + def clear_operation + end + + # A general status for this operation, indicates whether it is currently running or in one of the terminal statuses. +# Updated once when the operation is originally scheduled, and again when it reaches a terminal status. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # A general status for this operation, indicates whether it is currently running or in one of the terminal statuses. +# Updated once when the operation is originally scheduled, and again when it reaches a terminal status. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # A general status for this operation, indicates whether it is currently running or in one of the terminal statuses. +# Updated once when the operation is originally scheduled, and again when it reaches a terminal status. + sig { void } + def clear_status + end + + # More detailed breakdown of NEXUS_OPERATION_EXECUTION_STATUS_RUNNING. + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # More detailed breakdown of NEXUS_OPERATION_EXECUTION_STATUS_RUNNING. + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # More detailed breakdown of NEXUS_OPERATION_EXECUTION_STATUS_RUNNING. + sig { void } + def clear_state + end + + # Schedule-to-close timeout for this operation. +# (-- 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_close_timeout + end + + # Schedule-to-close timeout for this operation. +# (-- 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_close_timeout=(value) + end + + # Schedule-to-close timeout for this operation. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Schedule-to-start timeout for this operation. +# (-- 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 + + # Schedule-to-start timeout for this operation. +# (-- 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 + + # Schedule-to-start timeout for this operation. +# (-- 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 + + # Start-to-close timeout for this operation. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Start-to-close timeout for this operation. +# (-- 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 start_to_close_timeout=(value) + end + + # Start-to-close timeout for this operation. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # The number of attempts made to deliver the start operation request. +# This number is approximate, it is incremented when a task is added to the history queue. +# In practice, there could be more attempts if a task is executed but fails to commit, or less attempts if a task +# was never executed. + sig { returns(Integer) } + def attempt + end + + # The number of attempts made to deliver the start operation request. +# This number is approximate, it is incremented when a task is added to the history queue. +# In practice, there could be more attempts if a task is executed but fails to commit, or less attempts if a task +# was never executed. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The number of attempts made to deliver the start operation request. +# This number is approximate, it is incremented when a task is added to the history queue. +# In practice, there could be more attempts if a task is executed but fails to commit, or less attempts if a task +# was never executed. + sig { void } + def clear_attempt + end + + # Time the operation was originally scheduled via a StartNexusOperation request. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def schedule_time + end + + # Time the operation was originally scheduled via a StartNexusOperation request. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def schedule_time=(value) + end + + # Time the operation was originally scheduled via a StartNexusOperation request. + sig { void } + def clear_schedule_time + end + + # Scheduled time + schedule to close timeout. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def expiration_time + end + + # Scheduled time + schedule to close timeout. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def expiration_time=(value) + end + + # Scheduled time + schedule to close timeout. + sig { void } + def clear_expiration_time + end + + # Time when the operation transitioned to a closed state. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def close_time + end + + # Time when the operation transitioned to a closed state. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def close_time=(value) + end + + # Time when the operation transitioned to a closed state. + sig { void } + def clear_close_time + end + + # The time when the last attempt completed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_attempt_complete_time + end + + # The time when the last attempt completed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_attempt_complete_time=(value) + end + + # The time when the last attempt completed. + sig { void } + def clear_last_attempt_complete_time + end + + # The last attempt's failure, if any. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_attempt_failure + end + + # The last attempt's failure, if any. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_attempt_failure=(value) + end + + # The last attempt's failure, if any. + sig { void } + def clear_last_attempt_failure + end + + # The time when the next attempt is scheduled. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def next_attempt_schedule_time + end + + # The time when the next attempt is scheduled. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def next_attempt_schedule_time=(value) + end + + # The time when the next attempt is scheduled. + sig { void } + def clear_next_attempt_schedule_time + end + + # Elapsed time from schedule_time to now for running operations or to close_time for closed +# operations, including all attempts and backoff between attempts. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def execution_duration + end + + # Elapsed time from schedule_time to now for running operations or to close_time for closed +# operations, including all attempts and backoff between attempts. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def execution_duration=(value) + end + + # Elapsed time from schedule_time to now for running operations or to close_time for closed +# operations, including all attempts and backoff between attempts. + sig { void } + def clear_execution_duration + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::NexusOperationExecutionCancellationInfo)) } + def cancellation_info + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::NexusOperationExecutionCancellationInfo)).void } + def cancellation_info=(value) + end + + sig { void } + def clear_cancellation_info + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { returns(String) } + def blocked_reason + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { params(value: String).void } + def blocked_reason=(value) + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { void } + def clear_blocked_reason + end + + # Server-generated request ID used as an idempotency token when submitting start requests to +# the handler. Distinct from the request_id in StartNexusOperationRequest, which is the +# caller-side idempotency key for the StartNexusOperation RPC itself. + sig { returns(String) } + def request_id + end + + # Server-generated request ID used as an idempotency token when submitting start requests to +# the handler. Distinct from the request_id in StartNexusOperationRequest, which is the +# caller-side idempotency key for the StartNexusOperation RPC itself. + sig { params(value: String).void } + def request_id=(value) + end + + # Server-generated request ID used as an idempotency token when submitting start requests to +# the handler. Distinct from the request_id in StartNexusOperationRequest, which is the +# caller-side idempotency key for the StartNexusOperation RPC itself. + sig { void } + def clear_request_id + end + + # Operation token. Only set for asynchronous operations after a successful StartOperation call. + sig { returns(String) } + def operation_token + end + + # Operation token. Only set for asynchronous operations after a successful StartOperation call. + sig { params(value: String).void } + def operation_token=(value) + end + + # Operation token. Only set for asynchronous operations after a successful StartOperation call. + sig { void } + def clear_operation_token + end + + # Incremented each time the operation's state is mutated in persistence. + sig { returns(Integer) } + def state_transition_count + end + + # Incremented each time the operation's state is mutated in persistence. + sig { params(value: Integer).void } + def state_transition_count=(value) + end + + # Incremented each time the operation's state is mutated in persistence. + sig { void } + def clear_state_transition_count + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + # Header for context propagation and tracing purposes. + sig { returns(T::Hash[String, String]) } + def nexus_header + end + + # Header for context propagation and tracing purposes. + sig { params(value: ::Google::Protobuf::Map).void } + def nexus_header=(value) + end + + # Header for context propagation and tracing purposes. + sig { void } + def clear_nexus_header + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the operation. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the operation. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the operation. + sig { void } + def clear_user_metadata + end + + # Links attached by the handler of this operation on start or completion. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links attached by the handler of this operation on start or completion. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links attached by the handler of this operation on start or completion. + sig { void } + def clear_links + end + + # The identity of the client who started this operation. + sig { returns(String) } + def identity + end + + # The identity of the client who started this operation. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who started this operation. + sig { void } + def clear_identity + 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::Nexus::V1::NexusOperationExecutionInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::NexusOperationExecutionInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::NexusOperationExecutionInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::NexusOperationExecutionInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Limited Nexus operation information returned in the list response. +# When adding fields here, ensure that it is also present in NexusOperationExecutionInfo (note that it may already be present in +# NexusOperationExecutionInfo but not at the top-level). +class Temporalio::Api::Nexus::V1::NexusOperationExecutionListInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + operation_id: T.nilable(String), + run_id: T.nilable(String), + endpoint: T.nilable(String), + service: T.nilable(String), + operation: T.nilable(String), + schedule_time: T.nilable(Google::Protobuf::Timestamp), + close_time: T.nilable(Google::Protobuf::Timestamp), + status: T.nilable(T.any(Symbol, String, Integer)), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + state_transition_count: T.nilable(Integer), + execution_duration: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + operation_id: "", + run_id: "", + endpoint: "", + service: "", + operation: "", + schedule_time: nil, + close_time: nil, + status: :NEXUS_OPERATION_EXECUTION_STATUS_UNSPECIFIED, + search_attributes: nil, + state_transition_count: 0, + execution_duration: nil + ) + end + + # A unique identifier of this operation within its namespace along with run ID (below). + sig { returns(String) } + def operation_id + end + + # A unique identifier of this operation within its namespace along with run ID (below). + sig { params(value: String).void } + def operation_id=(value) + end + + # A unique identifier of this operation within its namespace along with run ID (below). + sig { void } + def clear_operation_id + end + + # The run ID of the standalone Nexus operation. + sig { returns(String) } + def run_id + end + + # The run ID of the standalone Nexus operation. + sig { params(value: String).void } + def run_id=(value) + end + + # The run ID of the standalone Nexus operation. + sig { void } + def clear_run_id + end + + # Endpoint name. + sig { returns(String) } + def endpoint + end + + # Endpoint name. + sig { params(value: String).void } + def endpoint=(value) + end + + # Endpoint name. + sig { void } + def clear_endpoint + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Operation name. + sig { returns(String) } + def operation + end + + # Operation name. + sig { params(value: String).void } + def operation=(value) + end + + # Operation name. + sig { void } + def clear_operation + end + + # Time the operation was originally scheduled via a StartNexusOperation request. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def schedule_time + end + + # Time the operation was originally scheduled via a StartNexusOperation request. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def schedule_time=(value) + end + + # Time the operation was originally scheduled via a StartNexusOperation request. + sig { void } + def clear_schedule_time + end + + # If the operation is in a terminal status, this field represents the time the operation transitioned to that status. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def close_time + end + + # If the operation is in a terminal status, this field represents the time the operation transitioned to that status. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def close_time=(value) + end + + # If the operation is in a terminal status, this field represents the time the operation transitioned to that status. + sig { void } + def clear_close_time + end + + # The status is updated once, when the operation is originally scheduled, and again when the operation reaches a terminal status. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # The status is updated once, when the operation is originally scheduled, and again when the operation reaches a terminal status. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # The status is updated once, when the operation is originally scheduled, and again when the operation reaches a terminal status. + sig { void } + def clear_status + end + + # Search attributes from the start request. + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # Search attributes from the start request. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # Search attributes from the start request. + sig { void } + def clear_search_attributes + end + + # Updated on terminal status. + sig { returns(Integer) } + def state_transition_count + end + + # Updated on terminal status. + sig { params(value: Integer).void } + def state_transition_count=(value) + end + + # Updated on terminal status. + sig { void } + def clear_state_transition_count + end + + # The difference between close time and scheduled time. +# This field is only populated if the operation is closed. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def execution_duration + end + + # The difference between close time and scheduled time. +# This field is only populated if the operation is closed. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def execution_duration=(value) + end + + # The difference between close time and scheduled time. +# This field is only populated if the operation is closed. + sig { void } + def clear_execution_duration + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Nexus::V1::NexusOperationExecutionListInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::NexusOperationExecutionListInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::NexusOperationExecutionListInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::NexusOperationExecutionListInfo, 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::Nexus::V1::Request::Capabilities + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + temporal_failure_responses: T.nilable(T::Boolean) + ).void + end + def initialize( + temporal_failure_responses: false + ) + end + + # If set, handlers may use temporal.api.failure.v1.Failure instances to return failures to the server. +# This also allows handler and operation errors to have their own messages and stack traces. + sig { returns(T::Boolean) } + def temporal_failure_responses + end + + # If set, handlers may use temporal.api.failure.v1.Failure instances to return failures to the server. +# This also allows handler and operation errors to have their own messages and stack traces. + sig { params(value: T::Boolean).void } + def temporal_failure_responses=(value) + end + + # If set, handlers may use temporal.api.failure.v1.Failure instances to return failures to the server. +# This also allows handler and operation errors to have their own messages and stack traces. + sig { void } + def clear_temporal_failure_responses + 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::Nexus::V1::Request::Capabilities) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Request::Capabilities).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::Request::Capabilities) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::Request::Capabilities, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# An operation completed successfully. +class Temporalio::Api::Nexus::V1::StartOperationResponse::Sync + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + payload: T.nilable(Temporalio::Api::Common::V1::Payload), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Nexus::V1::Link)]) + ).void + end + def initialize( + payload: nil, + links: [] + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def payload + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def payload=(value) + end + + sig { void } + def clear_payload + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Nexus::V1::Link)]) } + def links + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + sig { void } + def clear_links + 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::Nexus::V1::StartOperationResponse::Sync) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::StartOperationResponse::Sync).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::StartOperationResponse::Sync) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::StartOperationResponse::Sync, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# The operation will complete asynchronously. +# The returned ID can be used to reference this operation. +class Temporalio::Api::Nexus::V1::StartOperationResponse::Async + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + operation_id: T.nilable(String), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Nexus::V1::Link)]), + operation_token: T.nilable(String) + ).void + end + def initialize( + operation_id: "", + links: [], + operation_token: "" + ) + end + + # Deprecated. Renamed to operation_token. + sig { returns(String) } + def operation_id + end + + # Deprecated. Renamed to operation_token. + sig { params(value: String).void } + def operation_id=(value) + end + + # Deprecated. Renamed to operation_token. + sig { void } + def clear_operation_id + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Nexus::V1::Link)]) } + def links + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + sig { void } + def clear_links + end + + sig { returns(String) } + def operation_token + end + + sig { params(value: String).void } + def operation_token=(value) + end + + sig { void } + def clear_operation_token + 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::Nexus::V1::StartOperationResponse::Async) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::StartOperationResponse::Async).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::StartOperationResponse::Async) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::StartOperationResponse::Async, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Target a worker polling on a Nexus task queue in a specific namespace. +class Temporalio::Api::Nexus::V1::EndpointTarget::Worker + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(String) + ).void + end + def initialize( + namespace: "", + task_queue: "" + ) + end + + # Namespace to route requests to. + sig { returns(String) } + def namespace + end + + # Namespace to route requests to. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace to route requests to. + sig { void } + def clear_namespace + end + + # Nexus task queue to route requests to. + sig { returns(String) } + def task_queue + end + + # Nexus task queue to route requests to. + sig { params(value: String).void } + def task_queue=(value) + end + + # Nexus task queue to route requests to. + sig { void } + def clear_task_queue + 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::Nexus::V1::EndpointTarget::Worker) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::EndpointTarget::Worker).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::EndpointTarget::Worker) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::EndpointTarget::Worker, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Target an external server by URL. +# At a later point, this will support providing credentials, in the meantime, an http.RoundTripper can be injected +# into the server to modify the request. +class Temporalio::Api::Nexus::V1::EndpointTarget::External + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + url: T.nilable(String) + ).void + end + def initialize( + url: "" + ) + end + + # URL to call. + sig { returns(String) } + def url + end + + # URL to call. + sig { params(value: String).void } + def url=(value) + end + + # URL to call. + sig { void } + def clear_url + 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::Nexus::V1::EndpointTarget::External) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::EndpointTarget::External).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexus::V1::EndpointTarget::External) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexus::V1::EndpointTarget::External, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/nexusservices/workerservice/v1/request_response.rbi b/temporalio/rbi/temporalio/api/nexusservices/workerservice/v1/request_response.rbi new file mode 100644 index 00000000..4232a97b --- /dev/null +++ b/temporalio/rbi/temporalio/api/nexusservices/workerservice/v1/request_response.rbi @@ -0,0 +1,124 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/nexusservices/workerservice/v1/request_response.proto +# typed: strict + +# Request payload for the "ExecuteCommands" Nexus operation. +class Temporalio::Api::Nexusservices::Workerservice::V1::ExecuteCommandsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + commands: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerCommand)]) + ).void + end + def initialize( + commands: [] + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerCommand)]) } + def commands + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def commands=(value) + end + + sig { void } + def clear_commands + 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::Nexusservices::Workerservice::V1::ExecuteCommandsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexusservices::Workerservice::V1::ExecuteCommandsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexusservices::Workerservice::V1::ExecuteCommandsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexusservices::Workerservice::V1::ExecuteCommandsRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Response payload for the "ExecuteCommands" Nexus operation. +# The results list must be 1:1 with the commands list in the request (same size and order). +class Temporalio::Api::Nexusservices::Workerservice::V1::ExecuteCommandsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + results: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerCommandResult)]) + ).void + end + def initialize( + results: [] + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerCommandResult)]) } + def results + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def results=(value) + end + + sig { void } + def clear_results + 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::Nexusservices::Workerservice::V1::ExecuteCommandsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Nexusservices::Workerservice::V1::ExecuteCommandsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Nexusservices::Workerservice::V1::ExecuteCommandsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Nexusservices::Workerservice::V1::ExecuteCommandsResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/operatorservice.rbi b/temporalio/rbi/temporalio/api/operatorservice.rbi new file mode 100644 index 00000000..8c8f1a84 --- /dev/null +++ b/temporalio/rbi/temporalio/api/operatorservice.rbi @@ -0,0 +1,5 @@ +# typed: true + +# Generated code. DO NOT EDIT! + +module Temporalio::Api::OperatorService; end diff --git a/temporalio/rbi/temporalio/api/operatorservice/v1/request_response.rbi b/temporalio/rbi/temporalio/api/operatorservice/v1/request_response.rbi new file mode 100644 index 00000000..6d11c03c --- /dev/null +++ b/temporalio/rbi/temporalio/api/operatorservice/v1/request_response.rbi @@ -0,0 +1,1836 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/operatorservice/v1/request_response.proto +# typed: strict + +class Temporalio::Api::OperatorService::V1::AddSearchAttributesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + search_attributes: T.nilable(T::Hash[String, T.any(Symbol, String, Integer)]), + namespace: T.nilable(String) + ).void + end + def initialize( + search_attributes: ::Google::Protobuf::Map.new(:string, :enum), + namespace: "" + ) + end + + # Mapping between search attribute name and its IndexedValueType. + sig { returns(T::Hash[String, T.any(Symbol, Integer)]) } + def search_attributes + end + + # Mapping between search attribute name and its IndexedValueType. + sig { params(value: ::Google::Protobuf::Map).void } + def search_attributes=(value) + end + + # Mapping between search attribute name and its IndexedValueType. + sig { void } + def clear_search_attributes + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + 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::OperatorService::V1::AddSearchAttributesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::AddSearchAttributesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::AddSearchAttributesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::AddSearchAttributesRequest, 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::OperatorService::V1::AddSearchAttributesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::OperatorService::V1::AddSearchAttributesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::AddSearchAttributesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::AddSearchAttributesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::AddSearchAttributesResponse, 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::OperatorService::V1::RemoveSearchAttributesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + search_attributes: T.nilable(T::Array[String]), + namespace: T.nilable(String) + ).void + end + def initialize( + search_attributes: [], + namespace: "" + ) + end + + # Search attribute names to delete. + sig { returns(T::Array[String]) } + def search_attributes + end + + # Search attribute names to delete. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def search_attributes=(value) + end + + # Search attribute names to delete. + sig { void } + def clear_search_attributes + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + 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::OperatorService::V1::RemoveSearchAttributesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::RemoveSearchAttributesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::RemoveSearchAttributesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::RemoveSearchAttributesRequest, 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::OperatorService::V1::RemoveSearchAttributesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::OperatorService::V1::RemoveSearchAttributesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::RemoveSearchAttributesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::RemoveSearchAttributesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::RemoveSearchAttributesResponse, 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::OperatorService::V1::ListSearchAttributesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String) + ).void + end + def initialize( + namespace: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + 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::OperatorService::V1::ListSearchAttributesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListSearchAttributesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::ListSearchAttributesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListSearchAttributesRequest, 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::OperatorService::V1::ListSearchAttributesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + custom_attributes: T.nilable(T::Hash[String, T.any(Symbol, String, Integer)]), + system_attributes: T.nilable(T::Hash[String, T.any(Symbol, String, Integer)]), + storage_schema: T.nilable(T::Hash[String, String]) + ).void + end + def initialize( + custom_attributes: ::Google::Protobuf::Map.new(:string, :enum), + system_attributes: ::Google::Protobuf::Map.new(:string, :enum), + storage_schema: ::Google::Protobuf::Map.new(:string, :string) + ) + end + + # Mapping between custom (user-registered) search attribute name to its IndexedValueType. + sig { returns(T::Hash[String, T.any(Symbol, Integer)]) } + def custom_attributes + end + + # Mapping between custom (user-registered) search attribute name to its IndexedValueType. + sig { params(value: ::Google::Protobuf::Map).void } + def custom_attributes=(value) + end + + # Mapping between custom (user-registered) search attribute name to its IndexedValueType. + sig { void } + def clear_custom_attributes + end + + # Mapping between system (predefined) search attribute name to its IndexedValueType. + sig { returns(T::Hash[String, T.any(Symbol, Integer)]) } + def system_attributes + end + + # Mapping between system (predefined) search attribute name to its IndexedValueType. + sig { params(value: ::Google::Protobuf::Map).void } + def system_attributes=(value) + end + + # Mapping between system (predefined) search attribute name to its IndexedValueType. + sig { void } + def clear_system_attributes + end + + # Mapping from the attribute name to the visibility storage native type. + sig { returns(T::Hash[String, String]) } + def storage_schema + end + + # Mapping from the attribute name to the visibility storage native type. + sig { params(value: ::Google::Protobuf::Map).void } + def storage_schema=(value) + end + + # Mapping from the attribute name to the visibility storage native type. + sig { void } + def clear_storage_schema + 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::OperatorService::V1::ListSearchAttributesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListSearchAttributesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::ListSearchAttributesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListSearchAttributesResponse, 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::OperatorService::V1::DeleteNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + namespace_id: T.nilable(String), + namespace_delete_delay: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + namespace: "", + namespace_id: "", + namespace_delete_delay: nil + ) + end + + # Only one of namespace or namespace_id must be specified to identify namespace. + sig { returns(String) } + def namespace + end + + # Only one of namespace or namespace_id must be specified to identify namespace. + sig { params(value: String).void } + def namespace=(value) + end + + # Only one of namespace or namespace_id must be specified to identify namespace. + sig { void } + def clear_namespace + end + + sig { returns(String) } + def namespace_id + end + + sig { params(value: String).void } + def namespace_id=(value) + end + + sig { void } + def clear_namespace_id + end + + # If provided, the deletion of namespace info will be delayed for the given duration (0 means no delay). +# If not provided, the default delay configured in the cluster will be used. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def namespace_delete_delay + end + + # If provided, the deletion of namespace info will be delayed for the given duration (0 means no delay). +# If not provided, the default delay configured in the cluster will be used. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def namespace_delete_delay=(value) + end + + # If provided, the deletion of namespace info will be delayed for the given duration (0 means no delay). +# If not provided, the default delay configured in the cluster will be used. + sig { void } + def clear_namespace_delete_delay + 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::OperatorService::V1::DeleteNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::DeleteNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::DeleteNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::DeleteNamespaceRequest, 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::OperatorService::V1::DeleteNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deleted_namespace: T.nilable(String) + ).void + end + def initialize( + deleted_namespace: "" + ) + end + + # Temporary namespace name that is used during reclaim resources step. + sig { returns(String) } + def deleted_namespace + end + + # Temporary namespace name that is used during reclaim resources step. + sig { params(value: String).void } + def deleted_namespace=(value) + end + + # Temporary namespace name that is used during reclaim resources step. + sig { void } + def clear_deleted_namespace + 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::OperatorService::V1::DeleteNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::DeleteNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::DeleteNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::DeleteNamespaceResponse, 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::OperatorService::V1::AddOrUpdateRemoteClusterRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + frontend_address: T.nilable(String), + enable_remote_cluster_connection: T.nilable(T::Boolean), + frontend_http_address: T.nilable(String), + enable_replication: T.nilable(T::Boolean) + ).void + end + def initialize( + frontend_address: "", + enable_remote_cluster_connection: false, + frontend_http_address: "", + enable_replication: false + ) + end + + # Frontend Address is a cross cluster accessible address for gRPC traffic. This field is required. + sig { returns(String) } + def frontend_address + end + + # Frontend Address is a cross cluster accessible address for gRPC traffic. This field is required. + sig { params(value: String).void } + def frontend_address=(value) + end + + # Frontend Address is a cross cluster accessible address for gRPC traffic. This field is required. + sig { void } + def clear_frontend_address + end + + # Flag to enable / disable the cross cluster connection. + sig { returns(T::Boolean) } + def enable_remote_cluster_connection + end + + # Flag to enable / disable the cross cluster connection. + sig { params(value: T::Boolean).void } + def enable_remote_cluster_connection=(value) + end + + # Flag to enable / disable the cross cluster connection. + sig { void } + def clear_enable_remote_cluster_connection + end + + # Frontend HTTP Address is a cross cluster accessible address for HTTP traffic. This field is optional. If not provided +# on update, the existing HTTP address will be removed. + sig { returns(String) } + def frontend_http_address + end + + # Frontend HTTP Address is a cross cluster accessible address for HTTP traffic. This field is optional. If not provided +# on update, the existing HTTP address will be removed. + sig { params(value: String).void } + def frontend_http_address=(value) + end + + # Frontend HTTP Address is a cross cluster accessible address for HTTP traffic. This field is optional. If not provided +# on update, the existing HTTP address will be removed. + sig { void } + def clear_frontend_http_address + end + + # Controls whether replication streams are active. + sig { returns(T::Boolean) } + def enable_replication + end + + # Controls whether replication streams are active. + sig { params(value: T::Boolean).void } + def enable_replication=(value) + end + + # Controls whether replication streams are active. + sig { void } + def clear_enable_replication + 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::OperatorService::V1::AddOrUpdateRemoteClusterRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::AddOrUpdateRemoteClusterRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::AddOrUpdateRemoteClusterRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::AddOrUpdateRemoteClusterRequest, 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::OperatorService::V1::AddOrUpdateRemoteClusterResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::OperatorService::V1::AddOrUpdateRemoteClusterResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::AddOrUpdateRemoteClusterResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::AddOrUpdateRemoteClusterResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::AddOrUpdateRemoteClusterResponse, 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::OperatorService::V1::RemoveRemoteClusterRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cluster_name: T.nilable(String) + ).void + end + def initialize( + cluster_name: "" + ) + end + + # Remote cluster name to be removed. + sig { returns(String) } + def cluster_name + end + + # Remote cluster name to be removed. + sig { params(value: String).void } + def cluster_name=(value) + end + + # Remote cluster name to be removed. + sig { void } + def clear_cluster_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::OperatorService::V1::RemoveRemoteClusterRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::RemoveRemoteClusterRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::RemoveRemoteClusterRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::RemoveRemoteClusterRequest, 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::OperatorService::V1::RemoveRemoteClusterResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::OperatorService::V1::RemoveRemoteClusterResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::RemoveRemoteClusterResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::RemoveRemoteClusterResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::RemoveRemoteClusterResponse, 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::OperatorService::V1::ListClustersRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + next_page_token: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + next_page_token: "" + ) + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::OperatorService::V1::ListClustersRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListClustersRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::ListClustersRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListClustersRequest, 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::OperatorService::V1::ListClustersResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + clusters: T.nilable(T::Array[T.nilable(Temporalio::Api::OperatorService::V1::ClusterMetadata)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + clusters: [], + next_page_token: "" + ) + end + + # List of all cluster information + sig { returns(T::Array[T.nilable(Temporalio::Api::OperatorService::V1::ClusterMetadata)]) } + def clusters + end + + # List of all cluster information + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def clusters=(value) + end + + # List of all cluster information + sig { void } + def clear_clusters + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::OperatorService::V1::ListClustersResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListClustersResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::ListClustersResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListClustersResponse, 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::OperatorService::V1::ClusterMetadata + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cluster_name: T.nilable(String), + cluster_id: T.nilable(String), + address: T.nilable(String), + http_address: T.nilable(String), + initial_failover_version: T.nilable(Integer), + history_shard_count: T.nilable(Integer), + is_connection_enabled: T.nilable(T::Boolean), + is_replication_enabled: T.nilable(T::Boolean) + ).void + end + def initialize( + cluster_name: "", + cluster_id: "", + address: "", + http_address: "", + initial_failover_version: 0, + history_shard_count: 0, + is_connection_enabled: false, + is_replication_enabled: false + ) + end + + # Name of the cluster name. + sig { returns(String) } + def cluster_name + end + + # Name of the cluster name. + sig { params(value: String).void } + def cluster_name=(value) + end + + # Name of the cluster name. + sig { void } + def clear_cluster_name + end + + # Id of the cluster. + sig { returns(String) } + def cluster_id + end + + # Id of the cluster. + sig { params(value: String).void } + def cluster_id=(value) + end + + # Id of the cluster. + sig { void } + def clear_cluster_id + end + + # gRPC address. + sig { returns(String) } + def address + end + + # gRPC address. + sig { params(value: String).void } + def address=(value) + end + + # gRPC address. + sig { void } + def clear_address + end + + # HTTP address, if one exists. + sig { returns(String) } + def http_address + end + + # HTTP address, if one exists. + sig { params(value: String).void } + def http_address=(value) + end + + # HTTP address, if one exists. + sig { void } + def clear_http_address + end + + # A unique failover version across all connected clusters. + sig { returns(Integer) } + def initial_failover_version + end + + # A unique failover version across all connected clusters. + sig { params(value: Integer).void } + def initial_failover_version=(value) + end + + # A unique failover version across all connected clusters. + sig { void } + def clear_initial_failover_version + end + + # History service shard number. + sig { returns(Integer) } + def history_shard_count + end + + # History service shard number. + sig { params(value: Integer).void } + def history_shard_count=(value) + end + + # History service shard number. + sig { void } + def clear_history_shard_count + end + + # A flag to indicate if a connection is active. + sig { returns(T::Boolean) } + def is_connection_enabled + end + + # A flag to indicate if a connection is active. + sig { params(value: T::Boolean).void } + def is_connection_enabled=(value) + end + + # A flag to indicate if a connection is active. + sig { void } + def clear_is_connection_enabled + end + + # A flag to indicate if replication is enabled. + sig { returns(T::Boolean) } + def is_replication_enabled + end + + # A flag to indicate if replication is enabled. + sig { params(value: T::Boolean).void } + def is_replication_enabled=(value) + end + + # A flag to indicate if replication is enabled. + sig { void } + def clear_is_replication_enabled + 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::OperatorService::V1::ClusterMetadata) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ClusterMetadata).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::ClusterMetadata) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ClusterMetadata, 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::OperatorService::V1::GetNexusEndpointRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String) + ).void + end + def initialize( + id: "" + ) + end + + # Server-generated unique endpoint ID. + sig { returns(String) } + def id + end + + # Server-generated unique endpoint ID. + sig { params(value: String).void } + def id=(value) + end + + # Server-generated unique endpoint ID. + sig { void } + def clear_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::OperatorService::V1::GetNexusEndpointRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::GetNexusEndpointRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::GetNexusEndpointRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::GetNexusEndpointRequest, 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::OperatorService::V1::GetNexusEndpointResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint: T.nilable(Temporalio::Api::Nexus::V1::Endpoint) + ).void + end + def initialize( + endpoint: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Endpoint)) } + def endpoint + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Endpoint)).void } + def endpoint=(value) + end + + sig { void } + def clear_endpoint + 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::OperatorService::V1::GetNexusEndpointResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::GetNexusEndpointResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::GetNexusEndpointResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::GetNexusEndpointResponse, 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::OperatorService::V1::CreateNexusEndpointRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec) + ).void + end + def initialize( + spec: nil + ) + end + + # Endpoint definition to create. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec)) } + def spec + end + + # Endpoint definition to create. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec)).void } + def spec=(value) + end + + # Endpoint definition to create. + sig { void } + def clear_spec + 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::OperatorService::V1::CreateNexusEndpointRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::CreateNexusEndpointRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::CreateNexusEndpointRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::CreateNexusEndpointRequest, 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::OperatorService::V1::CreateNexusEndpointResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint: T.nilable(Temporalio::Api::Nexus::V1::Endpoint) + ).void + end + def initialize( + endpoint: nil + ) + end + + # Data post acceptance. Can be used to issue additional updates to this record. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Endpoint)) } + def endpoint + end + + # Data post acceptance. Can be used to issue additional updates to this record. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Endpoint)).void } + def endpoint=(value) + end + + # Data post acceptance. Can be used to issue additional updates to this record. + sig { void } + def clear_endpoint + 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::OperatorService::V1::CreateNexusEndpointResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::CreateNexusEndpointResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::CreateNexusEndpointResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::CreateNexusEndpointResponse, 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::OperatorService::V1::UpdateNexusEndpointRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + version: T.nilable(Integer), + spec: T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec) + ).void + end + def initialize( + id: "", + version: 0, + spec: nil + ) + end + + # Server-generated unique endpoint ID. + sig { returns(String) } + def id + end + + # Server-generated unique endpoint ID. + sig { params(value: String).void } + def id=(value) + end + + # Server-generated unique endpoint ID. + sig { void } + def clear_id + end + + # Data version for this endpoint. Must match current version. + sig { returns(Integer) } + def version + end + + # Data version for this endpoint. Must match current version. + sig { params(value: Integer).void } + def version=(value) + end + + # Data version for this endpoint. Must match current version. + sig { void } + def clear_version + end + + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec)) } + def spec + end + + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::EndpointSpec)).void } + def spec=(value) + end + + sig { void } + def clear_spec + 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::OperatorService::V1::UpdateNexusEndpointRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::UpdateNexusEndpointRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::UpdateNexusEndpointRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::UpdateNexusEndpointRequest, 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::OperatorService::V1::UpdateNexusEndpointResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint: T.nilable(Temporalio::Api::Nexus::V1::Endpoint) + ).void + end + def initialize( + endpoint: nil + ) + end + + # Data post acceptance. Can be used to issue additional updates to this record. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Endpoint)) } + def endpoint + end + + # Data post acceptance. Can be used to issue additional updates to this record. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Endpoint)).void } + def endpoint=(value) + end + + # Data post acceptance. Can be used to issue additional updates to this record. + sig { void } + def clear_endpoint + 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::OperatorService::V1::UpdateNexusEndpointResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::UpdateNexusEndpointResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::UpdateNexusEndpointResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::UpdateNexusEndpointResponse, 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::OperatorService::V1::DeleteNexusEndpointRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + version: T.nilable(Integer) + ).void + end + def initialize( + id: "", + version: 0 + ) + end + + # Server-generated unique endpoint ID. + sig { returns(String) } + def id + end + + # Server-generated unique endpoint ID. + sig { params(value: String).void } + def id=(value) + end + + # Server-generated unique endpoint ID. + sig { void } + def clear_id + end + + # Data version for this endpoint. Must match current version. + sig { returns(Integer) } + def version + end + + # Data version for this endpoint. Must match current version. + sig { params(value: Integer).void } + def version=(value) + end + + # Data version for this endpoint. Must match current version. + sig { void } + def clear_version + 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::OperatorService::V1::DeleteNexusEndpointRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::DeleteNexusEndpointRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::DeleteNexusEndpointRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::DeleteNexusEndpointRequest, 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::OperatorService::V1::DeleteNexusEndpointResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::OperatorService::V1::DeleteNexusEndpointResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::DeleteNexusEndpointResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::DeleteNexusEndpointResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::DeleteNexusEndpointResponse, 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::OperatorService::V1::ListNexusEndpointsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + name: T.nilable(String) + ).void + end + def initialize( + page_size: 0, + next_page_token: "", + name: "" + ) + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + # To get the next page, pass in `ListNexusEndpointsResponse.next_page_token` from the previous page's +# response, the token will be empty if there's no other page. +# Note: the last page may be empty if the total number of endpoints registered is a multiple of the page size. + sig { returns(String) } + def next_page_token + end + + # To get the next page, pass in `ListNexusEndpointsResponse.next_page_token` from the previous page's +# response, the token will be empty if there's no other page. +# Note: the last page may be empty if the total number of endpoints registered is a multiple of the page size. + sig { params(value: String).void } + def next_page_token=(value) + end + + # To get the next page, pass in `ListNexusEndpointsResponse.next_page_token` from the previous page's +# response, the token will be empty if there's no other page. +# Note: the last page may be empty if the total number of endpoints registered is a multiple of the page size. + sig { void } + def clear_next_page_token + end + + # Name of the incoming endpoint to filter on - optional. Specifying this will result in zero or one results. +# (-- api-linter: core::203::field-behavior-required=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { returns(String) } + def name + end + + # Name of the incoming endpoint to filter on - optional. Specifying this will result in zero or one results. +# (-- api-linter: core::203::field-behavior-required=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { params(value: String).void } + def name=(value) + end + + # Name of the incoming endpoint to filter on - optional. Specifying this will result in zero or one results. +# (-- api-linter: core::203::field-behavior-required=disabled +# aip.dev/not-precedent: Not following linter rules. --) + sig { void } + def clear_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::OperatorService::V1::ListNexusEndpointsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListNexusEndpointsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::ListNexusEndpointsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListNexusEndpointsRequest, 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::OperatorService::V1::ListNexusEndpointsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + next_page_token: T.nilable(String), + endpoints: T.nilable(T::Array[T.nilable(Temporalio::Api::Nexus::V1::Endpoint)]) + ).void + end + def initialize( + next_page_token: "", + endpoints: [] + ) + end + + # Token for getting the next page. + sig { returns(String) } + def next_page_token + end + + # Token for getting the next page. + sig { params(value: String).void } + def next_page_token=(value) + end + + # Token for getting the next page. + sig { void } + def clear_next_page_token + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Nexus::V1::Endpoint)]) } + def endpoints + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def endpoints=(value) + end + + sig { void } + def clear_endpoints + 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::OperatorService::V1::ListNexusEndpointsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListNexusEndpointsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::OperatorService::V1::ListNexusEndpointsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::OperatorService::V1::ListNexusEndpointsResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/operatorservice/v1/service.rbi b/temporalio/rbi/temporalio/api/operatorservice/v1/service.rbi new file mode 100644 index 00000000..56e0b391 --- /dev/null +++ b/temporalio/rbi/temporalio/api/operatorservice/v1/service.rbi @@ -0,0 +1,3 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/operatorservice/v1/service.proto +# typed: strict diff --git a/temporalio/rbi/temporalio/api/payload_visitor.rbi b/temporalio/rbi/temporalio/api/payload_visitor.rbi new file mode 100644 index 00000000..68843152 --- /dev/null +++ b/temporalio/rbi/temporalio/api/payload_visitor.rbi @@ -0,0 +1,861 @@ +# typed: true + +# Generated code. DO NOT EDIT! + +class Temporalio::Api::PayloadVisitor + extend T::Sig + + sig do + params( + on_enter: T.nilable(T.proc.params(value: Object).returns(Object)), + on_exit: T.nilable(T.proc.params(value: Object).returns(Object)), + skip_search_attributes: T::Boolean, + traverse_any: T::Boolean, + block: T.proc.params(value: Object).returns(Object) + ).void + end + def initialize( + on_enter: T.unsafe(nil), + on_exit: T.unsafe(nil), + skip_search_attributes: T.unsafe(false), + traverse_any: T.unsafe(false), + &block + ); end + + sig { params(value: Object).returns(NilClass) } + def run(value); end + + sig { params(value: Object).void } + def _run_activation(value); end + + sig { params(value: Object).void } + def _run_activation_completion(value); end + + private + + sig { params(name: String).returns(String) } + def method_name_from_proto_name(name); end + + sig { params(value: Object).returns(Object) } + def api_common_v1_payload(value); end + + sig { params(value: Object).returns(Object) } + def api_common_v1_payload_repeated(value); end + + sig { params(value: Object).void } + def google_protobuf_any(value); end + +sig { params(value: Object).void } + def api_activity_v1_activity_execution_info(value); end + + sig { params(value: Object).void } + def api_activity_v1_activity_execution_list_info(value); end + + sig { params(value: Object).void } + def api_activity_v1_activity_execution_outcome(value); end + + sig { params(value: Object).void } + def api_activity_v1_callback_info(value); end + + sig { params(value: Object).void } + def api_batch_v1_batch_operation_reset(value); end + + sig { params(value: Object).void } + def api_batch_v1_batch_operation_signal(value); end + + sig { params(value: Object).void } + def api_batch_v1_batch_operation_termination(value); end + + sig { params(value: Object).void } + def api_callback_v1_callback_info(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_add_namespace_region_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_add_user_group_member_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_account_audit_log_sink_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_api_key_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_billing_report_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_connectivity_rule_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_namespace_export_sink_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_namespace_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_nexus_endpoint_request(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_nexus_endpoint_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_service_account_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_user_group_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_create_user_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_account_audit_log_sink_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_api_key_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_connectivity_rule_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_namespace_export_sink_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_namespace_region_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_namespace_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_nexus_endpoint_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_service_account_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_user_group_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_delete_user_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_failover_namespace_region_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_get_async_operation_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_get_nexus_endpoint_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_get_nexus_endpoints_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_remove_user_group_member_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_rename_custom_search_attribute_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_set_service_account_namespace_access_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_set_user_group_namespace_access_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_set_user_namespace_access_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_account_audit_log_sink_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_account_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_api_key_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_namespace_export_sink_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_namespace_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_namespace_tags_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_nexus_endpoint_request(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_nexus_endpoint_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_service_account_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_user_group_response(value); end + + sig { params(value: Object).void } + def api_cloud_cloudservice_v1_update_user_response(value); end + + sig { params(value: Object).void } + def api_cloud_nexus_v1_endpoint(value); end + + sig { params(value: Object).void } + def api_cloud_nexus_v1_endpoint_spec(value); end + + sig { params(value: Object).void } + def api_cloud_operation_v1_async_operation(value); end + + sig { params(value: Object).void } + def api_command_v1_cancel_workflow_execution_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_command(value); end + + sig { params(value: Object).void } + def api_command_v1_complete_workflow_execution_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_continue_as_new_workflow_execution_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_fail_workflow_execution_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_modify_workflow_properties_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_record_marker_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_schedule_activity_task_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_schedule_nexus_operation_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_signal_external_workflow_execution_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_start_child_workflow_execution_command_attributes(value); end + + sig { params(value: Object).void } + def api_command_v1_upsert_workflow_search_attributes_command_attributes(value); end + + sig { params(value: Object).void } + def api_common_v1_header(value); end + + sig { params(value: Object).void } + def api_common_v1_memo(value); end + + sig { params(value: Object).void } + def api_common_v1_payloads(value); end + + sig { params(value: Object).void } + def api_common_v1_search_attributes(value); end + + sig { params(value: Object).void } + def api_compute_v1_compute_config(value); end + + sig { params(value: Object).void } + def api_compute_v1_compute_config_scaling_group(value); end + + sig { params(value: Object).void } + def api_compute_v1_compute_config_scaling_group_update(value); end + + sig { params(value: Object).void } + def api_compute_v1_compute_provider(value); end + + sig { params(value: Object).void } + def api_compute_v1_compute_scaler(value); end + + sig { params(value: Object).void } + def api_deployment_v1_deployment_info(value); end + + sig { params(value: Object).void } + def api_deployment_v1_update_deployment_metadata(value); end + + sig { params(value: Object).void } + def api_deployment_v1_version_metadata(value); end + + sig { params(value: Object).void } + def api_deployment_v1_worker_deployment_version_info(value); end + + sig { params(value: Object).void } + def api_export_v1_workflow_execution(value); end + + sig { params(value: Object).void } + def api_export_v1_workflow_executions(value); end + + sig { params(value: Object).void } + def api_failure_v1_application_failure_info(value); end + + sig { params(value: Object).void } + def api_failure_v1_canceled_failure_info(value); end + + sig { params(value: Object).void } + def api_failure_v1_failure(value); end + + sig { params(value: Object).void } + def api_failure_v1_reset_workflow_failure_info(value); end + + sig { params(value: Object).void } + def api_failure_v1_timeout_failure_info(value); end + + sig { params(value: Object).void } + def api_history_v1_activity_task_canceled_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_activity_task_completed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_activity_task_failed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_activity_task_scheduled_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_activity_task_started_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_activity_task_timed_out_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_child_workflow_execution_canceled_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_child_workflow_execution_completed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_child_workflow_execution_failed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_child_workflow_execution_started_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_history(value); end + + sig { params(value: Object).void } + def api_history_v1_history_event(value); end + + sig { params(value: Object).void } + def api_history_v1_marker_recorded_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_nexus_operation_cancel_request_failed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_nexus_operation_canceled_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_nexus_operation_completed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_nexus_operation_failed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_nexus_operation_scheduled_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_nexus_operation_timed_out_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_signal_external_workflow_execution_initiated_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_start_child_workflow_execution_initiated_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_upsert_workflow_search_attributes_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_canceled_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_completed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_continued_as_new_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_failed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_signaled_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_started_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_terminated_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_update_accepted_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_update_admitted_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_update_completed_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_execution_update_rejected_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_properties_modified_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_properties_modified_externally_event_attributes(value); end + + sig { params(value: Object).void } + def api_history_v1_workflow_task_failed_event_attributes(value); end + + sig { params(value: Object).void } + def api_nexus_v1_endpoint(value); end + + sig { params(value: Object).void } + def api_nexus_v1_endpoint_spec(value); end + + sig { params(value: Object).void } + def api_nexus_v1_nexus_operation_execution_cancellation_info(value); end + + sig { params(value: Object).void } + def api_nexus_v1_nexus_operation_execution_info(value); end + + sig { params(value: Object).void } + def api_nexus_v1_nexus_operation_execution_list_info(value); end + + sig { params(value: Object).void } + def api_nexus_v1_request(value); end + + sig { params(value: Object).void } + def api_nexus_v1_response(value); end + + sig { params(value: Object).void } + def api_nexus_v1_start_operation_request(value); end + + sig { params(value: Object).void } + def api_nexus_v1_start_operation_response(value); end + + sig { params(value: Object).void } + def api_nexus_v1_start_operation_response_sync(value); end + + sig { params(value: Object).void } + def api_operatorservice_v1_create_nexus_endpoint_request(value); end + + sig { params(value: Object).void } + def api_operatorservice_v1_create_nexus_endpoint_response(value); end + + sig { params(value: Object).void } + def api_operatorservice_v1_get_nexus_endpoint_response(value); end + + sig { params(value: Object).void } + def api_operatorservice_v1_list_nexus_endpoints_response(value); end + + sig { params(value: Object).void } + def api_operatorservice_v1_update_nexus_endpoint_request(value); end + + sig { params(value: Object).void } + def api_operatorservice_v1_update_nexus_endpoint_response(value); end + + sig { params(value: Object).void } + def api_protocol_v1_message(value); end + + sig { params(value: Object).void } + def api_query_v1_workflow_query(value); end + + sig { params(value: Object).void } + def api_query_v1_workflow_query_result(value); end + + sig { params(value: Object).void } + def api_schedule_v1_schedule(value); end + + sig { params(value: Object).void } + def api_schedule_v1_schedule_action(value); end + + sig { params(value: Object).void } + def api_schedule_v1_schedule_list_entry(value); end + + sig { params(value: Object).void } + def api_sdk_v1_user_metadata(value); end + + sig { params(value: Object).void } + def api_update_v1_input(value); end + + sig { params(value: Object).void } + def api_update_v1_outcome(value); end + + sig { params(value: Object).void } + def api_update_v1_request(value); end + + sig { params(value: Object).void } + def api_workflow_v1_callback_info(value); end + + sig { params(value: Object).void } + def api_workflow_v1_new_workflow_execution_info(value); end + + sig { params(value: Object).void } + def api_workflow_v1_nexus_operation_cancellation_info(value); end + + sig { params(value: Object).void } + def api_workflow_v1_pending_activity_info(value); end + + sig { params(value: Object).void } + def api_workflow_v1_pending_nexus_operation_info(value); end + + sig { params(value: Object).void } + def api_workflow_v1_post_reset_operation(value); end + + sig { params(value: Object).void } + def api_workflow_v1_post_reset_operation_signal_workflow(value); end + + sig { params(value: Object).void } + def api_workflow_v1_workflow_execution_config(value); end + + sig { params(value: Object).void } + def api_workflow_v1_workflow_execution_info(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_count_activity_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_count_activity_executions_response_aggregation_group(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_count_nexus_operation_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_count_nexus_operation_executions_response_aggregation_group(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_count_schedules_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_count_schedules_response_aggregation_group(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_count_workflow_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_count_workflow_executions_response_aggregation_group(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_create_schedule_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_create_worker_deployment_version_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_describe_activity_execution_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_describe_deployment_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_describe_nexus_operation_execution_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_describe_schedule_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_describe_worker_deployment_version_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_describe_workflow_execution_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_execute_multi_operation_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_execute_multi_operation_request_operation(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_execute_multi_operation_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_execute_multi_operation_response_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_get_current_deployment_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_get_deployment_reachability_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_get_workflow_execution_history_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_get_workflow_execution_history_reverse_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_list_activity_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_list_archived_workflow_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_list_closed_workflow_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_list_nexus_operation_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_list_open_workflow_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_list_schedules_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_list_workflow_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_poll_activity_execution_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_poll_activity_task_queue_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_poll_nexus_operation_execution_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_poll_nexus_task_queue_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_poll_workflow_execution_update_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_poll_workflow_task_queue_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_query_workflow_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_query_workflow_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_record_activity_task_heartbeat_by_id_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_record_activity_task_heartbeat_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_reset_workflow_execution_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_activity_task_canceled_by_id_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_activity_task_canceled_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_activity_task_completed_by_id_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_activity_task_completed_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_activity_task_failed_by_id_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_activity_task_failed_by_id_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_activity_task_failed_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_activity_task_failed_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_nexus_task_completed_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_nexus_task_failed_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_query_task_completed_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_workflow_task_completed_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_workflow_task_completed_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_respond_workflow_task_failed_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_scan_workflow_executions_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_set_current_deployment_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_set_current_deployment_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_signal_with_start_workflow_execution_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_signal_workflow_execution_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_start_activity_execution_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_start_batch_operation_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_start_nexus_operation_execution_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_start_workflow_execution_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_start_workflow_execution_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_terminate_workflow_execution_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_update_schedule_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_update_worker_deployment_version_compute_config_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_update_worker_deployment_version_metadata_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_update_worker_deployment_version_metadata_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_update_workflow_execution_request(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_update_workflow_execution_response(value); end + + sig { params(value: Object).void } + def api_workflowservice_v1_validate_worker_deployment_version_compute_config_request(value); end + + sig { params(value: Object).void } + def coresdk_activity_result_activity_resolution(value); end + + sig { params(value: Object).void } + def coresdk_activity_result_cancellation(value); end + + sig { params(value: Object).void } + def coresdk_activity_result_failure(value); end + + sig { params(value: Object).void } + def coresdk_activity_result_success(value); end + + sig { params(value: Object).void } + def coresdk_child_workflow_cancellation(value); end + + sig { params(value: Object).void } + def coresdk_child_workflow_child_workflow_result(value); end + + sig { params(value: Object).void } + def coresdk_child_workflow_failure(value); end + + sig { params(value: Object).void } + def coresdk_child_workflow_success(value); end + + sig { params(value: Object).void } + def coresdk_nexus_nexus_operation_result(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_do_update(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_initialize_workflow(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_query_workflow(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_resolve_activity(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_resolve_child_workflow_execution(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_resolve_child_workflow_execution_start(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_resolve_child_workflow_execution_start_cancelled(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_resolve_nexus_operation(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_resolve_nexus_operation_start(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_resolve_request_cancel_external_workflow(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_resolve_signal_external_workflow(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_signal_workflow(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_workflow_activation(value); end + + sig { params(value: Object).void } + def coresdk_workflow_activation_workflow_activation_job(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_complete_workflow_execution(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_continue_as_new_workflow_execution(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_fail_workflow_execution(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_modify_workflow_properties(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_query_result(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_query_success(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_schedule_activity(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_schedule_local_activity(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_schedule_nexus_operation(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_signal_external_workflow_execution(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_start_child_workflow_execution(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_update_response(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_upsert_workflow_search_attributes(value); end + + sig { params(value: Object).void } + def coresdk_workflow_commands_workflow_command(value); end + + sig { params(value: Object).void } + def coresdk_workflow_completion_failure(value); end + + sig { params(value: Object).void } + def coresdk_workflow_completion_success(value); end + + sig { params(value: Object).void } + def coresdk_workflow_completion_workflow_activation_completion(value); end + +end diff --git a/temporalio/rbi/temporalio/api/protoc_gen_openapiv2/options/annotations.rbi b/temporalio/rbi/temporalio/api/protoc_gen_openapiv2/options/annotations.rbi new file mode 100644 index 00000000..2ae01b52 --- /dev/null +++ b/temporalio/rbi/temporalio/api/protoc_gen_openapiv2/options/annotations.rbi @@ -0,0 +1,3 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: protoc-gen-openapiv2/options/annotations.proto +# typed: strict diff --git a/temporalio/rbi/temporalio/api/protoc_gen_openapiv2/options/openapiv2.rbi b/temporalio/rbi/temporalio/api/protoc_gen_openapiv2/options/openapiv2.rbi new file mode 100644 index 00000000..357b172c --- /dev/null +++ b/temporalio/rbi/temporalio/api/protoc_gen_openapiv2/options/openapiv2.rbi @@ -0,0 +1,3482 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: protoc-gen-openapiv2/options/openapiv2.proto +# typed: strict + +# `Swagger` is a representation of OpenAPI v2 specification's Swagger object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#swaggerObject +# +# Example: +# +# option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { +# info: { +# title: "Echo API"; +# version: "1.0"; +# description: ""; +# contact: { +# name: "gRPC-Gateway project"; +# url: "https://github.com/grpc-ecosystem/grpc-gateway"; +# email: "none@example.com"; +# }; +# license: { +# name: "BSD 3-Clause License"; +# url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; +# }; +# }; +# schemes: HTTPS; +# consumes: "application/json"; +# produces: "application/json"; +# }; +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Swagger + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + swagger: T.nilable(String), + info: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Info), + host: T.nilable(String), + base_path: T.nilable(String), + schemes: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + consumes: T.nilable(T::Array[String]), + produces: T.nilable(T::Array[String]), + responses: T.nilable(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Response)]), + security_definitions: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityDefinitions), + security: T.nilable(T::Array[T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement)]), + tags: T.nilable(T::Array[T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Tag)]), + external_docs: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation), + extensions: T.nilable(T::Hash[String, T.nilable(Google::Protobuf::Value)]) + ).void + end + def initialize( + swagger: "", + info: nil, + host: "", + base_path: "", + schemes: [], + consumes: [], + produces: [], + responses: ::Google::Protobuf::Map.new(:string, :message, Grpc::Gateway::ProtocGenOpenapiv2::Options::Response), + security_definitions: nil, + security: [], + tags: [], + external_docs: nil, + extensions: ::Google::Protobuf::Map.new(:string, :message, Google::Protobuf::Value) + ) + end + + # Specifies the OpenAPI Specification version being used. It can be +# used by the OpenAPI UI and other clients to interpret the API listing. The +# value MUST be "2.0". + sig { returns(String) } + def swagger + end + + # Specifies the OpenAPI Specification version being used. It can be +# used by the OpenAPI UI and other clients to interpret the API listing. The +# value MUST be "2.0". + sig { params(value: String).void } + def swagger=(value) + end + + # Specifies the OpenAPI Specification version being used. It can be +# used by the OpenAPI UI and other clients to interpret the API listing. The +# value MUST be "2.0". + sig { void } + def clear_swagger + end + + # Provides metadata about the API. The metadata can be used by the +# clients if needed. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Info)) } + def info + end + + # Provides metadata about the API. The metadata can be used by the +# clients if needed. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Info)).void } + def info=(value) + end + + # Provides metadata about the API. The metadata can be used by the +# clients if needed. + sig { void } + def clear_info + end + + # The host (name or ip) serving the API. This MUST be the host only and does +# not include the scheme nor sub-paths. It MAY include a port. If the host is +# not included, the host serving the documentation is to be used (including +# the port). The host does not support path templating. + sig { returns(String) } + def host + end + + # The host (name or ip) serving the API. This MUST be the host only and does +# not include the scheme nor sub-paths. It MAY include a port. If the host is +# not included, the host serving the documentation is to be used (including +# the port). The host does not support path templating. + sig { params(value: String).void } + def host=(value) + end + + # The host (name or ip) serving the API. This MUST be the host only and does +# not include the scheme nor sub-paths. It MAY include a port. If the host is +# not included, the host serving the documentation is to be used (including +# the port). The host does not support path templating. + sig { void } + def clear_host + end + + # The base path on which the API is served, which is relative to the host. If +# it is not included, the API is served directly under the host. The value +# MUST start with a leading slash (/). The basePath does not support path +# templating. +# Note that using `base_path` does not change the endpoint paths that are +# generated in the resulting OpenAPI file. If you wish to use `base_path` +# with relatively generated OpenAPI paths, the `base_path` prefix must be +# manually removed from your `google.api.http` paths and your code changed to +# serve the API from the `base_path`. + sig { returns(String) } + def base_path + end + + # The base path on which the API is served, which is relative to the host. If +# it is not included, the API is served directly under the host. The value +# MUST start with a leading slash (/). The basePath does not support path +# templating. +# Note that using `base_path` does not change the endpoint paths that are +# generated in the resulting OpenAPI file. If you wish to use `base_path` +# with relatively generated OpenAPI paths, the `base_path` prefix must be +# manually removed from your `google.api.http` paths and your code changed to +# serve the API from the `base_path`. + sig { params(value: String).void } + def base_path=(value) + end + + # The base path on which the API is served, which is relative to the host. If +# it is not included, the API is served directly under the host. The value +# MUST start with a leading slash (/). The basePath does not support path +# templating. +# Note that using `base_path` does not change the endpoint paths that are +# generated in the resulting OpenAPI file. If you wish to use `base_path` +# with relatively generated OpenAPI paths, the `base_path` prefix must be +# manually removed from your `google.api.http` paths and your code changed to +# serve the API from the `base_path`. + sig { void } + def clear_base_path + end + + # The transfer protocol of the API. Values MUST be from the list: "http", +# "https", "ws", "wss". If the schemes is not included, the default scheme to +# be used is the one used to access the OpenAPI definition itself. + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def schemes + end + + # The transfer protocol of the API. Values MUST be from the list: "http", +# "https", "ws", "wss". If the schemes is not included, the default scheme to +# be used is the one used to access the OpenAPI definition itself. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def schemes=(value) + end + + # The transfer protocol of the API. Values MUST be from the list: "http", +# "https", "ws", "wss". If the schemes is not included, the default scheme to +# be used is the one used to access the OpenAPI definition itself. + sig { void } + def clear_schemes + end + + # A list of MIME types the APIs can consume. This is global to all APIs but +# can be overridden on specific API calls. Value MUST be as described under +# Mime Types. + sig { returns(T::Array[String]) } + def consumes + end + + # A list of MIME types the APIs can consume. This is global to all APIs but +# can be overridden on specific API calls. Value MUST be as described under +# Mime Types. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def consumes=(value) + end + + # A list of MIME types the APIs can consume. This is global to all APIs but +# can be overridden on specific API calls. Value MUST be as described under +# Mime Types. + sig { void } + def clear_consumes + end + + # A list of MIME types the APIs can produce. This is global to all APIs but +# can be overridden on specific API calls. Value MUST be as described under +# Mime Types. + sig { returns(T::Array[String]) } + def produces + end + + # A list of MIME types the APIs can produce. This is global to all APIs but +# can be overridden on specific API calls. Value MUST be as described under +# Mime Types. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def produces=(value) + end + + # A list of MIME types the APIs can produce. This is global to all APIs but +# can be overridden on specific API calls. Value MUST be as described under +# Mime Types. + sig { void } + def clear_produces + end + + # An object to hold responses that can be used across operations. This +# property does not define global responses for all operations. + sig { returns(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Response)]) } + def responses + end + + # An object to hold responses that can be used across operations. This +# property does not define global responses for all operations. + sig { params(value: ::Google::Protobuf::Map).void } + def responses=(value) + end + + # An object to hold responses that can be used across operations. This +# property does not define global responses for all operations. + sig { void } + def clear_responses + end + + # Security scheme definitions that can be used across the specification. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityDefinitions)) } + def security_definitions + end + + # Security scheme definitions that can be used across the specification. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityDefinitions)).void } + def security_definitions=(value) + end + + # Security scheme definitions that can be used across the specification. + sig { void } + def clear_security_definitions + end + + # A declaration of which security schemes are applied for the API as a whole. +# The list of values describes alternative security schemes that can be used +# (that is, there is a logical OR between the security requirements). +# Individual operations can override this definition. + sig { returns(T::Array[T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement)]) } + def security + end + + # A declaration of which security schemes are applied for the API as a whole. +# The list of values describes alternative security schemes that can be used +# (that is, there is a logical OR between the security requirements). +# Individual operations can override this definition. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def security=(value) + end + + # A declaration of which security schemes are applied for the API as a whole. +# The list of values describes alternative security schemes that can be used +# (that is, there is a logical OR between the security requirements). +# Individual operations can override this definition. + sig { void } + def clear_security + end + + # A list of tags for API documentation control. Tags can be used for logical +# grouping of operations by resources or any other qualifier. + sig { returns(T::Array[T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Tag)]) } + def tags + end + + # A list of tags for API documentation control. Tags can be used for logical +# grouping of operations by resources or any other qualifier. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def tags=(value) + end + + # A list of tags for API documentation control. Tags can be used for logical +# grouping of operations by resources or any other qualifier. + sig { void } + def clear_tags + end + + # Additional external documentation. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)) } + def external_docs + end + + # Additional external documentation. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)).void } + def external_docs=(value) + end + + # Additional external documentation. + sig { void } + def clear_external_docs + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { returns(T::Hash[String, T.nilable(Google::Protobuf::Value)]) } + def extensions + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { params(value: ::Google::Protobuf::Map).void } + def extensions=(value) + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { void } + def clear_extensions + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Swagger) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Swagger).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Swagger) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Swagger, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Operation` is a representation of OpenAPI v2 specification's Operation object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#operationObject +# +# Example: +# +# service EchoService { +# rpc Echo(SimpleMessage) returns (SimpleMessage) { +# option (google.api.http) = { +# get: "/v1/example/echo/{id}" +# }; +# +# option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = { +# summary: "Get a message."; +# operation_id: "getMessage"; +# tags: "echo"; +# responses: { +# key: "200" +# value: { +# description: "OK"; +# } +# } +# }; +# } +# } +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Operation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + tags: T.nilable(T::Array[String]), + summary: T.nilable(String), + description: T.nilable(String), + external_docs: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation), + operation_id: T.nilable(String), + consumes: T.nilable(T::Array[String]), + produces: T.nilable(T::Array[String]), + responses: T.nilable(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Response)]), + schemes: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + deprecated: T.nilable(T::Boolean), + security: T.nilable(T::Array[T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement)]), + extensions: T.nilable(T::Hash[String, T.nilable(Google::Protobuf::Value)]), + parameters: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Parameters) + ).void + end + def initialize( + tags: [], + summary: "", + description: "", + external_docs: nil, + operation_id: "", + consumes: [], + produces: [], + responses: ::Google::Protobuf::Map.new(:string, :message, Grpc::Gateway::ProtocGenOpenapiv2::Options::Response), + schemes: [], + deprecated: false, + security: [], + extensions: ::Google::Protobuf::Map.new(:string, :message, Google::Protobuf::Value), + parameters: nil + ) + end + + # A list of tags for API documentation control. Tags can be used for logical +# grouping of operations by resources or any other qualifier. + sig { returns(T::Array[String]) } + def tags + end + + # A list of tags for API documentation control. Tags can be used for logical +# grouping of operations by resources or any other qualifier. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def tags=(value) + end + + # A list of tags for API documentation control. Tags can be used for logical +# grouping of operations by resources or any other qualifier. + sig { void } + def clear_tags + end + + # A short summary of what the operation does. For maximum readability in the +# swagger-ui, this field SHOULD be less than 120 characters. + sig { returns(String) } + def summary + end + + # A short summary of what the operation does. For maximum readability in the +# swagger-ui, this field SHOULD be less than 120 characters. + sig { params(value: String).void } + def summary=(value) + end + + # A short summary of what the operation does. For maximum readability in the +# swagger-ui, this field SHOULD be less than 120 characters. + sig { void } + def clear_summary + end + + # A verbose explanation of the operation behavior. GFM syntax can be used for +# rich text representation. + sig { returns(String) } + def description + end + + # A verbose explanation of the operation behavior. GFM syntax can be used for +# rich text representation. + sig { params(value: String).void } + def description=(value) + end + + # A verbose explanation of the operation behavior. GFM syntax can be used for +# rich text representation. + sig { void } + def clear_description + end + + # Additional external documentation for this operation. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)) } + def external_docs + end + + # Additional external documentation for this operation. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)).void } + def external_docs=(value) + end + + # Additional external documentation for this operation. + sig { void } + def clear_external_docs + end + + # Unique string used to identify the operation. The id MUST be unique among +# all operations described in the API. Tools and libraries MAY use the +# operationId to uniquely identify an operation, therefore, it is recommended +# to follow common programming naming conventions. + sig { returns(String) } + def operation_id + end + + # Unique string used to identify the operation. The id MUST be unique among +# all operations described in the API. Tools and libraries MAY use the +# operationId to uniquely identify an operation, therefore, it is recommended +# to follow common programming naming conventions. + sig { params(value: String).void } + def operation_id=(value) + end + + # Unique string used to identify the operation. The id MUST be unique among +# all operations described in the API. Tools and libraries MAY use the +# operationId to uniquely identify an operation, therefore, it is recommended +# to follow common programming naming conventions. + sig { void } + def clear_operation_id + end + + # A list of MIME types the operation can consume. This overrides the consumes +# definition at the OpenAPI Object. An empty value MAY be used to clear the +# global definition. Value MUST be as described under Mime Types. + sig { returns(T::Array[String]) } + def consumes + end + + # A list of MIME types the operation can consume. This overrides the consumes +# definition at the OpenAPI Object. An empty value MAY be used to clear the +# global definition. Value MUST be as described under Mime Types. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def consumes=(value) + end + + # A list of MIME types the operation can consume. This overrides the consumes +# definition at the OpenAPI Object. An empty value MAY be used to clear the +# global definition. Value MUST be as described under Mime Types. + sig { void } + def clear_consumes + end + + # A list of MIME types the operation can produce. This overrides the produces +# definition at the OpenAPI Object. An empty value MAY be used to clear the +# global definition. Value MUST be as described under Mime Types. + sig { returns(T::Array[String]) } + def produces + end + + # A list of MIME types the operation can produce. This overrides the produces +# definition at the OpenAPI Object. An empty value MAY be used to clear the +# global definition. Value MUST be as described under Mime Types. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def produces=(value) + end + + # A list of MIME types the operation can produce. This overrides the produces +# definition at the OpenAPI Object. An empty value MAY be used to clear the +# global definition. Value MUST be as described under Mime Types. + sig { void } + def clear_produces + end + + # The list of possible responses as they are returned from executing this +# operation. + sig { returns(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Response)]) } + def responses + end + + # The list of possible responses as they are returned from executing this +# operation. + sig { params(value: ::Google::Protobuf::Map).void } + def responses=(value) + end + + # The list of possible responses as they are returned from executing this +# operation. + sig { void } + def clear_responses + end + + # The transfer protocol for the operation. Values MUST be from the list: +# "http", "https", "ws", "wss". The value overrides the OpenAPI Object +# schemes definition. + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def schemes + end + + # The transfer protocol for the operation. Values MUST be from the list: +# "http", "https", "ws", "wss". The value overrides the OpenAPI Object +# schemes definition. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def schemes=(value) + end + + # The transfer protocol for the operation. Values MUST be from the list: +# "http", "https", "ws", "wss". The value overrides the OpenAPI Object +# schemes definition. + sig { void } + def clear_schemes + end + + # Declares this operation to be deprecated. Usage of the declared operation +# should be refrained. Default value is false. + sig { returns(T::Boolean) } + def deprecated + end + + # Declares this operation to be deprecated. Usage of the declared operation +# should be refrained. Default value is false. + sig { params(value: T::Boolean).void } + def deprecated=(value) + end + + # Declares this operation to be deprecated. Usage of the declared operation +# should be refrained. Default value is false. + sig { void } + def clear_deprecated + end + + # A declaration of which security schemes are applied for this operation. The +# list of values describes alternative security schemes that can be used +# (that is, there is a logical OR between the security requirements). This +# definition overrides any declared top-level security. To remove a top-level +# security declaration, an empty array can be used. + sig { returns(T::Array[T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement)]) } + def security + end + + # A declaration of which security schemes are applied for this operation. The +# list of values describes alternative security schemes that can be used +# (that is, there is a logical OR between the security requirements). This +# definition overrides any declared top-level security. To remove a top-level +# security declaration, an empty array can be used. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def security=(value) + end + + # A declaration of which security schemes are applied for this operation. The +# list of values describes alternative security schemes that can be used +# (that is, there is a logical OR between the security requirements). This +# definition overrides any declared top-level security. To remove a top-level +# security declaration, an empty array can be used. + sig { void } + def clear_security + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { returns(T::Hash[String, T.nilable(Google::Protobuf::Value)]) } + def extensions + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { params(value: ::Google::Protobuf::Map).void } + def extensions=(value) + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { void } + def clear_extensions + end + + # Custom parameters such as HTTP request headers. +# See: https://swagger.io/docs/specification/2-0/describing-parameters/ +# and https://swagger.io/specification/v2/#parameter-object. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Parameters)) } + def parameters + end + + # Custom parameters such as HTTP request headers. +# See: https://swagger.io/docs/specification/2-0/describing-parameters/ +# and https://swagger.io/specification/v2/#parameter-object. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Parameters)).void } + def parameters=(value) + end + + # Custom parameters such as HTTP request headers. +# See: https://swagger.io/docs/specification/2-0/describing-parameters/ +# and https://swagger.io/specification/v2/#parameter-object. + sig { void } + def clear_parameters + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Operation) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Operation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Operation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Operation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Parameters` is a representation of OpenAPI v2 specification's parameters object. +# Note: This technically breaks compatibility with the OpenAPI 2 definition structure as we only +# allow header parameters to be set here since we do not want users specifying custom non-header +# parameters beyond those inferred from the Protobuf schema. +# See: https://swagger.io/specification/v2/#parameter-object +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Parameters + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + headers: T.nilable(T::Array[T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::HeaderParameter)]) + ).void + end + def initialize( + headers: [] + ) + end + + # `Headers` is one or more HTTP header parameter. +# See: https://swagger.io/docs/specification/2-0/describing-parameters/#header-parameters + sig { returns(T::Array[T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::HeaderParameter)]) } + def headers + end + + # `Headers` is one or more HTTP header parameter. +# See: https://swagger.io/docs/specification/2-0/describing-parameters/#header-parameters + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def headers=(value) + end + + # `Headers` is one or more HTTP header parameter. +# See: https://swagger.io/docs/specification/2-0/describing-parameters/#header-parameters + sig { void } + def clear_headers + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Parameters) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Parameters).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Parameters) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Parameters, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `HeaderParameter` a HTTP header parameter. +# See: https://swagger.io/specification/v2/#parameter-object +class Grpc::Gateway::ProtocGenOpenapiv2::Options::HeaderParameter + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + description: T.nilable(String), + type: T.nilable(T.any(Symbol, String, Integer)), + format: T.nilable(String), + required: T.nilable(T::Boolean) + ).void + end + def initialize( + name: "", + description: "", + type: :UNKNOWN, + format: "", + required: false + ) + end + + # `Name` is the header name. + sig { returns(String) } + def name + end + + # `Name` is the header name. + sig { params(value: String).void } + def name=(value) + end + + # `Name` is the header name. + sig { void } + def clear_name + end + + # `Description` is a short description of the header. + sig { returns(String) } + def description + end + + # `Description` is a short description of the header. + sig { params(value: String).void } + def description=(value) + end + + # `Description` is a short description of the header. + sig { void } + def clear_description + end + + # `Type` is the type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. +# See: https://swagger.io/specification/v2/#parameterType. + sig { returns(T.any(Symbol, Integer)) } + def type + end + + # `Type` is the type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. +# See: https://swagger.io/specification/v2/#parameterType. + sig { params(value: T.any(Symbol, String, Integer)).void } + def type=(value) + end + + # `Type` is the type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. +# See: https://swagger.io/specification/v2/#parameterType. + sig { void } + def clear_type + end + + # `Format` The extending format for the previously mentioned type. + sig { returns(String) } + def format + end + + # `Format` The extending format for the previously mentioned type. + sig { params(value: String).void } + def format=(value) + end + + # `Format` The extending format for the previously mentioned type. + sig { void } + def clear_format + end + + # `Required` indicates if the header is optional + sig { returns(T::Boolean) } + def required + end + + # `Required` indicates if the header is optional + sig { params(value: T::Boolean).void } + def required=(value) + end + + # `Required` indicates if the header is optional + sig { void } + def clear_required + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::HeaderParameter) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::HeaderParameter).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::HeaderParameter) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::HeaderParameter, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Header` is a representation of OpenAPI v2 specification's Header object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#headerObject +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Header + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + description: T.nilable(String), + type: T.nilable(String), + format: T.nilable(String), + default: T.nilable(String), + pattern: T.nilable(String) + ).void + end + def initialize( + description: "", + type: "", + format: "", + default: "", + pattern: "" + ) + end + + # `Description` is a short description of the header. + sig { returns(String) } + def description + end + + # `Description` is a short description of the header. + sig { params(value: String).void } + def description=(value) + end + + # `Description` is a short description of the header. + sig { void } + def clear_description + end + + # The type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. + sig { returns(String) } + def type + end + + # The type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. + sig { params(value: String).void } + def type=(value) + end + + # The type of the object. The value MUST be one of "string", "number", "integer", or "boolean". The "array" type is not supported. + sig { void } + def clear_type + end + + # `Format` The extending format for the previously mentioned type. + sig { returns(String) } + def format + end + + # `Format` The extending format for the previously mentioned type. + sig { params(value: String).void } + def format=(value) + end + + # `Format` The extending format for the previously mentioned type. + sig { void } + def clear_format + end + + # `Default` Declares the value of the header that the server will use if none is provided. +# See: https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-6.2. +# Unlike JSON Schema this value MUST conform to the defined type for the header. + sig { returns(String) } + def default + end + + # `Default` Declares the value of the header that the server will use if none is provided. +# See: https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-6.2. +# Unlike JSON Schema this value MUST conform to the defined type for the header. + sig { params(value: String).void } + def default=(value) + end + + # `Default` Declares the value of the header that the server will use if none is provided. +# See: https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-6.2. +# Unlike JSON Schema this value MUST conform to the defined type for the header. + sig { void } + def clear_default + end + + # 'Pattern' See https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.2.3. + sig { returns(String) } + def pattern + end + + # 'Pattern' See https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.2.3. + sig { params(value: String).void } + def pattern=(value) + end + + # 'Pattern' See https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.2.3. + sig { void } + def clear_pattern + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Header) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Header).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Header) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Header, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Response` is a representation of OpenAPI v2 specification's Response object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#responseObject +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Response + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + description: T.nilable(String), + schema: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Schema), + headers: T.nilable(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Header)]), + examples: T.nilable(T::Hash[String, String]), + extensions: T.nilable(T::Hash[String, T.nilable(Google::Protobuf::Value)]) + ).void + end + def initialize( + description: "", + schema: nil, + headers: ::Google::Protobuf::Map.new(:string, :message, Grpc::Gateway::ProtocGenOpenapiv2::Options::Header), + examples: ::Google::Protobuf::Map.new(:string, :string), + extensions: ::Google::Protobuf::Map.new(:string, :message, Google::Protobuf::Value) + ) + end + + # `Description` is a short description of the response. +# GFM syntax can be used for rich text representation. + sig { returns(String) } + def description + end + + # `Description` is a short description of the response. +# GFM syntax can be used for rich text representation. + sig { params(value: String).void } + def description=(value) + end + + # `Description` is a short description of the response. +# GFM syntax can be used for rich text representation. + sig { void } + def clear_description + end + + # `Schema` optionally defines the structure of the response. +# If `Schema` is not provided, it means there is no content to the response. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Schema)) } + def schema + end + + # `Schema` optionally defines the structure of the response. +# If `Schema` is not provided, it means there is no content to the response. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Schema)).void } + def schema=(value) + end + + # `Schema` optionally defines the structure of the response. +# If `Schema` is not provided, it means there is no content to the response. + sig { void } + def clear_schema + end + + # `Headers` A list of headers that are sent with the response. +# `Header` name is expected to be a string in the canonical format of the MIME header key +# See: https://golang.org/pkg/net/textproto/#CanonicalMIMEHeaderKey + sig { returns(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Header)]) } + def headers + end + + # `Headers` A list of headers that are sent with the response. +# `Header` name is expected to be a string in the canonical format of the MIME header key +# See: https://golang.org/pkg/net/textproto/#CanonicalMIMEHeaderKey + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + # `Headers` A list of headers that are sent with the response. +# `Header` name is expected to be a string in the canonical format of the MIME header key +# See: https://golang.org/pkg/net/textproto/#CanonicalMIMEHeaderKey + sig { void } + def clear_headers + end + + # `Examples` gives per-mimetype response examples. +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#example-object + sig { returns(T::Hash[String, String]) } + def examples + end + + # `Examples` gives per-mimetype response examples. +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#example-object + sig { params(value: ::Google::Protobuf::Map).void } + def examples=(value) + end + + # `Examples` gives per-mimetype response examples. +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#example-object + sig { void } + def clear_examples + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { returns(T::Hash[String, T.nilable(Google::Protobuf::Value)]) } + def extensions + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { params(value: ::Google::Protobuf::Map).void } + def extensions=(value) + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { void } + def clear_extensions + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Response) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Response).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Response) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Response, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Info` is a representation of OpenAPI v2 specification's Info object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#infoObject +# +# Example: +# +# option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { +# info: { +# title: "Echo API"; +# version: "1.0"; +# description: ""; +# contact: { +# name: "gRPC-Gateway project"; +# url: "https://github.com/grpc-ecosystem/grpc-gateway"; +# email: "none@example.com"; +# }; +# license: { +# name: "BSD 3-Clause License"; +# url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; +# }; +# }; +# ... +# }; +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Info + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + title: T.nilable(String), + description: T.nilable(String), + terms_of_service: T.nilable(String), + contact: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Contact), + license: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::License), + version: T.nilable(String), + extensions: T.nilable(T::Hash[String, T.nilable(Google::Protobuf::Value)]) + ).void + end + def initialize( + title: "", + description: "", + terms_of_service: "", + contact: nil, + license: nil, + version: "", + extensions: ::Google::Protobuf::Map.new(:string, :message, Google::Protobuf::Value) + ) + end + + # The title of the application. + sig { returns(String) } + def title + end + + # The title of the application. + sig { params(value: String).void } + def title=(value) + end + + # The title of the application. + sig { void } + def clear_title + end + + # A short description of the application. GFM syntax can be used for rich +# text representation. + sig { returns(String) } + def description + end + + # A short description of the application. GFM syntax can be used for rich +# text representation. + sig { params(value: String).void } + def description=(value) + end + + # A short description of the application. GFM syntax can be used for rich +# text representation. + sig { void } + def clear_description + end + + # The Terms of Service for the API. + sig { returns(String) } + def terms_of_service + end + + # The Terms of Service for the API. + sig { params(value: String).void } + def terms_of_service=(value) + end + + # The Terms of Service for the API. + sig { void } + def clear_terms_of_service + end + + # The contact information for the exposed API. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Contact)) } + def contact + end + + # The contact information for the exposed API. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Contact)).void } + def contact=(value) + end + + # The contact information for the exposed API. + sig { void } + def clear_contact + end + + # The license information for the exposed API. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::License)) } + def license + end + + # The license information for the exposed API. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::License)).void } + def license=(value) + end + + # The license information for the exposed API. + sig { void } + def clear_license + end + + # Provides the version of the application API (not to be confused +# with the specification version). + sig { returns(String) } + def version + end + + # Provides the version of the application API (not to be confused +# with the specification version). + sig { params(value: String).void } + def version=(value) + end + + # Provides the version of the application API (not to be confused +# with the specification version). + sig { void } + def clear_version + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { returns(T::Hash[String, T.nilable(Google::Protobuf::Value)]) } + def extensions + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { params(value: ::Google::Protobuf::Map).void } + def extensions=(value) + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { void } + def clear_extensions + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Info) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Info).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Info) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Info, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Contact` is a representation of OpenAPI v2 specification's Contact object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#contactObject +# +# Example: +# +# option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { +# info: { +# ... +# contact: { +# name: "gRPC-Gateway project"; +# url: "https://github.com/grpc-ecosystem/grpc-gateway"; +# email: "none@example.com"; +# }; +# ... +# }; +# ... +# }; +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Contact + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + url: T.nilable(String), + email: T.nilable(String) + ).void + end + def initialize( + name: "", + url: "", + email: "" + ) + end + + # The identifying name of the contact person/organization. + sig { returns(String) } + def name + end + + # The identifying name of the contact person/organization. + sig { params(value: String).void } + def name=(value) + end + + # The identifying name of the contact person/organization. + sig { void } + def clear_name + end + + # The URL pointing to the contact information. MUST be in the format of a +# URL. + sig { returns(String) } + def url + end + + # The URL pointing to the contact information. MUST be in the format of a +# URL. + sig { params(value: String).void } + def url=(value) + end + + # The URL pointing to the contact information. MUST be in the format of a +# URL. + sig { void } + def clear_url + end + + # The email address of the contact person/organization. MUST be in the format +# of an email address. + sig { returns(String) } + def email + end + + # The email address of the contact person/organization. MUST be in the format +# of an email address. + sig { params(value: String).void } + def email=(value) + end + + # The email address of the contact person/organization. MUST be in the format +# of an email address. + sig { void } + def clear_email + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Contact) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Contact).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Contact) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Contact, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `License` is a representation of OpenAPI v2 specification's License object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#licenseObject +# +# Example: +# +# option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { +# info: { +# ... +# license: { +# name: "BSD 3-Clause License"; +# url: "https://github.com/grpc-ecosystem/grpc-gateway/blob/main/LICENSE"; +# }; +# ... +# }; +# ... +# }; +class Grpc::Gateway::ProtocGenOpenapiv2::Options::License + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + url: T.nilable(String) + ).void + end + def initialize( + name: "", + url: "" + ) + end + + # The license name used for the API. + sig { returns(String) } + def name + end + + # The license name used for the API. + sig { params(value: String).void } + def name=(value) + end + + # The license name used for the API. + sig { void } + def clear_name + end + + # A URL to the license used for the API. MUST be in the format of a URL. + sig { returns(String) } + def url + end + + # A URL to the license used for the API. MUST be in the format of a URL. + sig { params(value: String).void } + def url=(value) + end + + # A URL to the license used for the API. MUST be in the format of a URL. + sig { void } + def clear_url + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::License) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::License).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::License) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::License, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `ExternalDocumentation` is a representation of OpenAPI v2 specification's +# ExternalDocumentation object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#externalDocumentationObject +# +# Example: +# +# option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = { +# ... +# external_docs: { +# description: "More about gRPC-Gateway"; +# url: "https://github.com/grpc-ecosystem/grpc-gateway"; +# } +# ... +# }; +class Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + description: T.nilable(String), + url: T.nilable(String) + ).void + end + def initialize( + description: "", + url: "" + ) + end + + # A short description of the target documentation. GFM syntax can be used for +# rich text representation. + sig { returns(String) } + def description + end + + # A short description of the target documentation. GFM syntax can be used for +# rich text representation. + sig { params(value: String).void } + def description=(value) + end + + # A short description of the target documentation. GFM syntax can be used for +# rich text representation. + sig { void } + def clear_description + end + + # The URL for the target documentation. Value MUST be in the format +# of a URL. + sig { returns(String) } + def url + end + + # The URL for the target documentation. Value MUST be in the format +# of a URL. + sig { params(value: String).void } + def url=(value) + end + + # The URL for the target documentation. Value MUST be in the format +# of a URL. + sig { void } + def clear_url + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Schema` is a representation of OpenAPI v2 specification's Schema object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Schema + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + json_schema: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema), + discriminator: T.nilable(String), + read_only: T.nilable(T::Boolean), + external_docs: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation), + example: T.nilable(String) + ).void + end + def initialize( + json_schema: nil, + discriminator: "", + read_only: false, + external_docs: nil, + example: "" + ) + end + + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema)) } + def json_schema + end + + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema)).void } + def json_schema=(value) + end + + sig { void } + def clear_json_schema + end + + # Adds support for polymorphism. The discriminator is the schema property +# name that is used to differentiate between other schema that inherit this +# schema. The property name used MUST be defined at this schema and it MUST +# be in the required property list. When used, the value MUST be the name of +# this schema or any schema that inherits it. + sig { returns(String) } + def discriminator + end + + # Adds support for polymorphism. The discriminator is the schema property +# name that is used to differentiate between other schema that inherit this +# schema. The property name used MUST be defined at this schema and it MUST +# be in the required property list. When used, the value MUST be the name of +# this schema or any schema that inherits it. + sig { params(value: String).void } + def discriminator=(value) + end + + # Adds support for polymorphism. The discriminator is the schema property +# name that is used to differentiate between other schema that inherit this +# schema. The property name used MUST be defined at this schema and it MUST +# be in the required property list. When used, the value MUST be the name of +# this schema or any schema that inherits it. + sig { void } + def clear_discriminator + end + + # Relevant only for Schema "properties" definitions. Declares the property as +# "read only". This means that it MAY be sent as part of a response but MUST +# NOT be sent as part of the request. Properties marked as readOnly being +# true SHOULD NOT be in the required list of the defined schema. Default +# value is false. + sig { returns(T::Boolean) } + def read_only + end + + # Relevant only for Schema "properties" definitions. Declares the property as +# "read only". This means that it MAY be sent as part of a response but MUST +# NOT be sent as part of the request. Properties marked as readOnly being +# true SHOULD NOT be in the required list of the defined schema. Default +# value is false. + sig { params(value: T::Boolean).void } + def read_only=(value) + end + + # Relevant only for Schema "properties" definitions. Declares the property as +# "read only". This means that it MAY be sent as part of a response but MUST +# NOT be sent as part of the request. Properties marked as readOnly being +# true SHOULD NOT be in the required list of the defined schema. Default +# value is false. + sig { void } + def clear_read_only + end + + # Additional external documentation for this schema. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)) } + def external_docs + end + + # Additional external documentation for this schema. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)).void } + def external_docs=(value) + end + + # Additional external documentation for this schema. + sig { void } + def clear_external_docs + end + + # A free-form property to include an example of an instance for this schema in JSON. +# This is copied verbatim to the output. + sig { returns(String) } + def example + end + + # A free-form property to include an example of an instance for this schema in JSON. +# This is copied verbatim to the output. + sig { params(value: String).void } + def example=(value) + end + + # A free-form property to include an example of an instance for this schema in JSON. +# This is copied verbatim to the output. + sig { void } + def clear_example + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Schema) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Schema).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Schema) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Schema, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `EnumSchema` is subset of fields from the OpenAPI v2 specification's Schema object. +# Only fields that are applicable to Enums are included +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject +# +# Example: +# +# option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_enum) = { +# ... +# title: "MyEnum"; +# description:"This is my nice enum"; +# example: "ZERO"; +# required: true; +# ... +# }; +class Grpc::Gateway::ProtocGenOpenapiv2::Options::EnumSchema + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + description: T.nilable(String), + default: T.nilable(String), + title: T.nilable(String), + required: T.nilable(T::Boolean), + read_only: T.nilable(T::Boolean), + external_docs: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation), + example: T.nilable(String), + ref: T.nilable(String), + extensions: T.nilable(T::Hash[String, T.nilable(Google::Protobuf::Value)]) + ).void + end + def initialize( + description: "", + default: "", + title: "", + required: false, + read_only: false, + external_docs: nil, + example: "", + ref: "", + extensions: ::Google::Protobuf::Map.new(:string, :message, Google::Protobuf::Value) + ) + end + + # A short description of the schema. + sig { returns(String) } + def description + end + + # A short description of the schema. + sig { params(value: String).void } + def description=(value) + end + + # A short description of the schema. + sig { void } + def clear_description + end + + sig { returns(String) } + def default + end + + sig { params(value: String).void } + def default=(value) + end + + sig { void } + def clear_default + end + + # The title of the schema. + sig { returns(String) } + def title + end + + # The title of the schema. + sig { params(value: String).void } + def title=(value) + end + + # The title of the schema. + sig { void } + def clear_title + end + + sig { returns(T::Boolean) } + def required + end + + sig { params(value: T::Boolean).void } + def required=(value) + end + + sig { void } + def clear_required + end + + sig { returns(T::Boolean) } + def read_only + end + + sig { params(value: T::Boolean).void } + def read_only=(value) + end + + sig { void } + def clear_read_only + end + + # Additional external documentation for this schema. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)) } + def external_docs + end + + # Additional external documentation for this schema. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)).void } + def external_docs=(value) + end + + # Additional external documentation for this schema. + sig { void } + def clear_external_docs + end + + sig { returns(String) } + def example + end + + sig { params(value: String).void } + def example=(value) + end + + sig { void } + def clear_example + end + + # Ref is used to define an external reference to include in the message. +# This could be a fully qualified proto message reference, and that type must +# be imported into the protofile. If no message is identified, the Ref will +# be used verbatim in the output. +# For example: +# `ref: ".google.protobuf.Timestamp"`. + sig { returns(String) } + def ref + end + + # Ref is used to define an external reference to include in the message. +# This could be a fully qualified proto message reference, and that type must +# be imported into the protofile. If no message is identified, the Ref will +# be used verbatim in the output. +# For example: +# `ref: ".google.protobuf.Timestamp"`. + sig { params(value: String).void } + def ref=(value) + end + + # Ref is used to define an external reference to include in the message. +# This could be a fully qualified proto message reference, and that type must +# be imported into the protofile. If no message is identified, the Ref will +# be used verbatim in the output. +# For example: +# `ref: ".google.protobuf.Timestamp"`. + sig { void } + def clear_ref + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { returns(T::Hash[String, T.nilable(Google::Protobuf::Value)]) } + def extensions + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { params(value: ::Google::Protobuf::Map).void } + def extensions=(value) + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { void } + def clear_extensions + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::EnumSchema) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::EnumSchema).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::EnumSchema) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::EnumSchema, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `JSONSchema` represents properties from JSON Schema taken, and as used, in +# the OpenAPI v2 spec. +# +# This includes changes made by OpenAPI v2. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject +# +# See also: https://cswr.github.io/JsonSchema/spec/basic_types/, +# https://github.com/json-schema-org/json-schema-spec/blob/master/schema.json +# +# Example: +# +# message SimpleMessage { +# option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema) = { +# json_schema: { +# title: "SimpleMessage" +# description: "A simple message." +# required: ["id"] +# } +# }; +# +# // Id represents the message identifier. +# string id = 1; [ +# (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = { +# description: "The unique identifier of the simple message." +# }]; +# } +class Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + ref: T.nilable(String), + title: T.nilable(String), + description: T.nilable(String), + default: T.nilable(String), + read_only: T.nilable(T::Boolean), + example: T.nilable(String), + multiple_of: T.nilable(Float), + maximum: T.nilable(Float), + exclusive_maximum: T.nilable(T::Boolean), + minimum: T.nilable(Float), + exclusive_minimum: T.nilable(T::Boolean), + max_length: T.nilable(Integer), + min_length: T.nilable(Integer), + pattern: T.nilable(String), + max_items: T.nilable(Integer), + min_items: T.nilable(Integer), + unique_items: T.nilable(T::Boolean), + max_properties: T.nilable(Integer), + min_properties: T.nilable(Integer), + required: T.nilable(T::Array[String]), + array: T.nilable(T::Array[String]), + type: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + format: T.nilable(String), + enum: T.nilable(T::Array[String]), + field_configuration: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::FieldConfiguration), + extensions: T.nilable(T::Hash[String, T.nilable(Google::Protobuf::Value)]) + ).void + end + def initialize( + ref: "", + title: "", + description: "", + default: "", + read_only: false, + example: "", + multiple_of: 0.0, + maximum: 0.0, + exclusive_maximum: false, + minimum: 0.0, + exclusive_minimum: false, + max_length: 0, + min_length: 0, + pattern: "", + max_items: 0, + min_items: 0, + unique_items: false, + max_properties: 0, + min_properties: 0, + required: [], + array: [], + type: [], + format: "", + enum: [], + field_configuration: nil, + extensions: ::Google::Protobuf::Map.new(:string, :message, Google::Protobuf::Value) + ) + end + + # Ref is used to define an external reference to include in the message. +# This could be a fully qualified proto message reference, and that type must +# be imported into the protofile. If no message is identified, the Ref will +# be used verbatim in the output. +# For example: +# `ref: ".google.protobuf.Timestamp"`. + sig { returns(String) } + def ref + end + + # Ref is used to define an external reference to include in the message. +# This could be a fully qualified proto message reference, and that type must +# be imported into the protofile. If no message is identified, the Ref will +# be used verbatim in the output. +# For example: +# `ref: ".google.protobuf.Timestamp"`. + sig { params(value: String).void } + def ref=(value) + end + + # Ref is used to define an external reference to include in the message. +# This could be a fully qualified proto message reference, and that type must +# be imported into the protofile. If no message is identified, the Ref will +# be used verbatim in the output. +# For example: +# `ref: ".google.protobuf.Timestamp"`. + sig { void } + def clear_ref + end + + # The title of the schema. + sig { returns(String) } + def title + end + + # The title of the schema. + sig { params(value: String).void } + def title=(value) + end + + # The title of the schema. + sig { void } + def clear_title + end + + # A short description of the schema. + sig { returns(String) } + def description + end + + # A short description of the schema. + sig { params(value: String).void } + def description=(value) + end + + # A short description of the schema. + sig { void } + def clear_description + end + + sig { returns(String) } + def default + end + + sig { params(value: String).void } + def default=(value) + end + + sig { void } + def clear_default + end + + sig { returns(T::Boolean) } + def read_only + end + + sig { params(value: T::Boolean).void } + def read_only=(value) + end + + sig { void } + def clear_read_only + end + + # A free-form property to include a JSON example of this field. This is copied +# verbatim to the output swagger.json. Quotes must be escaped. +# This property is the same for 2.0 and 3.0.0 https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/3.0.0.md#schemaObject https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + sig { returns(String) } + def example + end + + # A free-form property to include a JSON example of this field. This is copied +# verbatim to the output swagger.json. Quotes must be escaped. +# This property is the same for 2.0 and 3.0.0 https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/3.0.0.md#schemaObject https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + sig { params(value: String).void } + def example=(value) + end + + # A free-form property to include a JSON example of this field. This is copied +# verbatim to the output swagger.json. Quotes must be escaped. +# This property is the same for 2.0 and 3.0.0 https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/3.0.0.md#schemaObject https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#schemaObject + sig { void } + def clear_example + end + + sig { returns(Float) } + def multiple_of + end + + sig { params(value: Float).void } + def multiple_of=(value) + end + + sig { void } + def clear_multiple_of + end + + # Maximum represents an inclusive upper limit for a numeric instance. The +# value of MUST be a number, + sig { returns(Float) } + def maximum + end + + # Maximum represents an inclusive upper limit for a numeric instance. The +# value of MUST be a number, + sig { params(value: Float).void } + def maximum=(value) + end + + # Maximum represents an inclusive upper limit for a numeric instance. The +# value of MUST be a number, + sig { void } + def clear_maximum + end + + sig { returns(T::Boolean) } + def exclusive_maximum + end + + sig { params(value: T::Boolean).void } + def exclusive_maximum=(value) + end + + sig { void } + def clear_exclusive_maximum + end + + # minimum represents an inclusive lower limit for a numeric instance. The +# value of MUST be a number, + sig { returns(Float) } + def minimum + end + + # minimum represents an inclusive lower limit for a numeric instance. The +# value of MUST be a number, + sig { params(value: Float).void } + def minimum=(value) + end + + # minimum represents an inclusive lower limit for a numeric instance. The +# value of MUST be a number, + sig { void } + def clear_minimum + end + + sig { returns(T::Boolean) } + def exclusive_minimum + end + + sig { params(value: T::Boolean).void } + def exclusive_minimum=(value) + end + + sig { void } + def clear_exclusive_minimum + end + + sig { returns(Integer) } + def max_length + end + + sig { params(value: Integer).void } + def max_length=(value) + end + + sig { void } + def clear_max_length + end + + sig { returns(Integer) } + def min_length + end + + sig { params(value: Integer).void } + def min_length=(value) + end + + sig { void } + def clear_min_length + end + + sig { returns(String) } + def pattern + end + + sig { params(value: String).void } + def pattern=(value) + end + + sig { void } + def clear_pattern + end + + sig { returns(Integer) } + def max_items + end + + sig { params(value: Integer).void } + def max_items=(value) + end + + sig { void } + def clear_max_items + end + + sig { returns(Integer) } + def min_items + end + + sig { params(value: Integer).void } + def min_items=(value) + end + + sig { void } + def clear_min_items + end + + sig { returns(T::Boolean) } + def unique_items + end + + sig { params(value: T::Boolean).void } + def unique_items=(value) + end + + sig { void } + def clear_unique_items + end + + sig { returns(Integer) } + def max_properties + end + + sig { params(value: Integer).void } + def max_properties=(value) + end + + sig { void } + def clear_max_properties + end + + sig { returns(Integer) } + def min_properties + end + + sig { params(value: Integer).void } + def min_properties=(value) + end + + sig { void } + def clear_min_properties + end + + sig { returns(T::Array[String]) } + def required + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def required=(value) + end + + sig { void } + def clear_required + end + + # Items in 'array' must be unique. + sig { returns(T::Array[String]) } + def array + end + + # Items in 'array' must be unique. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def array=(value) + end + + # Items in 'array' must be unique. + sig { void } + def clear_array + end + + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def type + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def type=(value) + end + + sig { void } + def clear_type + end + + # `Format` + sig { returns(String) } + def format + end + + # `Format` + sig { params(value: String).void } + def format=(value) + end + + # `Format` + sig { void } + def clear_format + end + + # Items in `enum` must be unique https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.5.1 + sig { returns(T::Array[String]) } + def enum + end + + # Items in `enum` must be unique https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.5.1 + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def enum=(value) + end + + # Items in `enum` must be unique https://tools.ietf.org/html/draft-fge-json-schema-validation-00#section-5.5.1 + sig { void } + def clear_enum + end + + # Additional field level properties used when generating the OpenAPI v2 file. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::FieldConfiguration)) } + def field_configuration + end + + # Additional field level properties used when generating the OpenAPI v2 file. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::FieldConfiguration)).void } + def field_configuration=(value) + end + + # Additional field level properties used when generating the OpenAPI v2 file. + sig { void } + def clear_field_configuration + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { returns(T::Hash[String, T.nilable(Google::Protobuf::Value)]) } + def extensions + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { params(value: ::Google::Protobuf::Map).void } + def extensions=(value) + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { void } + def clear_extensions + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Tag` is a representation of OpenAPI v2 specification's Tag object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#tagObject +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Tag + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + description: T.nilable(String), + external_docs: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation), + extensions: T.nilable(T::Hash[String, T.nilable(Google::Protobuf::Value)]) + ).void + end + def initialize( + name: "", + description: "", + external_docs: nil, + extensions: ::Google::Protobuf::Map.new(:string, :message, Google::Protobuf::Value) + ) + end + + # The name of the tag. Use it to allow override of the name of a +# global Tag object, then use that name to reference the tag throughout the +# OpenAPI file. + sig { returns(String) } + def name + end + + # The name of the tag. Use it to allow override of the name of a +# global Tag object, then use that name to reference the tag throughout the +# OpenAPI file. + sig { params(value: String).void } + def name=(value) + end + + # The name of the tag. Use it to allow override of the name of a +# global Tag object, then use that name to reference the tag throughout the +# OpenAPI file. + sig { void } + def clear_name + end + + # A short description for the tag. GFM syntax can be used for rich text +# representation. + sig { returns(String) } + def description + end + + # A short description for the tag. GFM syntax can be used for rich text +# representation. + sig { params(value: String).void } + def description=(value) + end + + # A short description for the tag. GFM syntax can be used for rich text +# representation. + sig { void } + def clear_description + end + + # Additional external documentation for this tag. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)) } + def external_docs + end + + # Additional external documentation for this tag. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::ExternalDocumentation)).void } + def external_docs=(value) + end + + # Additional external documentation for this tag. + sig { void } + def clear_external_docs + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { returns(T::Hash[String, T.nilable(Google::Protobuf::Value)]) } + def extensions + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { params(value: ::Google::Protobuf::Map).void } + def extensions=(value) + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { void } + def clear_extensions + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Tag) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Tag).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Tag) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Tag, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `SecurityDefinitions` is a representation of OpenAPI v2 specification's +# Security Definitions object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securityDefinitionsObject +# +# A declaration of the security schemes available to be used in the +# specification. This does not enforce the security schemes on the operations +# and only serves to provide the relevant details for each scheme. +class Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityDefinitions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + security: T.nilable(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme)]) + ).void + end + def initialize( + security: ::Google::Protobuf::Map.new(:string, :message, Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme) + ) + end + + # A single security scheme definition, mapping a "name" to the scheme it +# defines. + sig { returns(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme)]) } + def security + end + + # A single security scheme definition, mapping a "name" to the scheme it +# defines. + sig { params(value: ::Google::Protobuf::Map).void } + def security=(value) + end + + # A single security scheme definition, mapping a "name" to the scheme it +# defines. + sig { void } + def clear_security + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityDefinitions) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityDefinitions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityDefinitions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityDefinitions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `SecurityScheme` is a representation of OpenAPI v2 specification's +# Security Scheme object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securitySchemeObject +# +# Allows the definition of a security scheme that can be used by the +# operations. Supported schemes are basic authentication, an API key (either as +# a header or as a query parameter) and OAuth2's common flows (implicit, +# password, application and access code). +class Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(T.any(Symbol, String, Integer)), + description: T.nilable(String), + name: T.nilable(String), + in: T.nilable(T.any(Symbol, String, Integer)), + flow: T.nilable(T.any(Symbol, String, Integer)), + authorization_url: T.nilable(String), + token_url: T.nilable(String), + scopes: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Scopes), + extensions: T.nilable(T::Hash[String, T.nilable(Google::Protobuf::Value)]) + ).void + end + def initialize( + type: :TYPE_INVALID, + description: "", + name: "", + in: :IN_INVALID, + flow: :FLOW_INVALID, + authorization_url: "", + token_url: "", + scopes: nil, + extensions: ::Google::Protobuf::Map.new(:string, :message, Google::Protobuf::Value) + ) + end + + # The type of the security scheme. Valid values are "basic", +# "apiKey" or "oauth2". + sig { returns(T.any(Symbol, Integer)) } + def type + end + + # The type of the security scheme. Valid values are "basic", +# "apiKey" or "oauth2". + sig { params(value: T.any(Symbol, String, Integer)).void } + def type=(value) + end + + # The type of the security scheme. Valid values are "basic", +# "apiKey" or "oauth2". + sig { void } + def clear_type + end + + # A short description for security scheme. + sig { returns(String) } + def description + end + + # A short description for security scheme. + sig { params(value: String).void } + def description=(value) + end + + # A short description for security scheme. + sig { void } + def clear_description + end + + # The name of the header or query parameter to be used. +# Valid for apiKey. + sig { returns(String) } + def name + end + + # The name of the header or query parameter to be used. +# Valid for apiKey. + sig { params(value: String).void } + def name=(value) + end + + # The name of the header or query parameter to be used. +# Valid for apiKey. + sig { void } + def clear_name + end + + # The location of the API key. Valid values are "query" or +# "header". +# Valid for apiKey. + sig { returns(T.any(Symbol, Integer)) } + def in + end + + # The location of the API key. Valid values are "query" or +# "header". +# Valid for apiKey. + sig { params(value: T.any(Symbol, String, Integer)).void } + def in=(value) + end + + # The location of the API key. Valid values are "query" or +# "header". +# Valid for apiKey. + sig { void } + def clear_in + end + + # The flow used by the OAuth2 security scheme. Valid values are +# "implicit", "password", "application" or "accessCode". +# Valid for oauth2. + sig { returns(T.any(Symbol, Integer)) } + def flow + end + + # The flow used by the OAuth2 security scheme. Valid values are +# "implicit", "password", "application" or "accessCode". +# Valid for oauth2. + sig { params(value: T.any(Symbol, String, Integer)).void } + def flow=(value) + end + + # The flow used by the OAuth2 security scheme. Valid values are +# "implicit", "password", "application" or "accessCode". +# Valid for oauth2. + sig { void } + def clear_flow + end + + # The authorization URL to be used for this flow. This SHOULD be in +# the form of a URL. +# Valid for oauth2/implicit and oauth2/accessCode. + sig { returns(String) } + def authorization_url + end + + # The authorization URL to be used for this flow. This SHOULD be in +# the form of a URL. +# Valid for oauth2/implicit and oauth2/accessCode. + sig { params(value: String).void } + def authorization_url=(value) + end + + # The authorization URL to be used for this flow. This SHOULD be in +# the form of a URL. +# Valid for oauth2/implicit and oauth2/accessCode. + sig { void } + def clear_authorization_url + end + + # The token URL to be used for this flow. This SHOULD be in the +# form of a URL. +# Valid for oauth2/password, oauth2/application and oauth2/accessCode. + sig { returns(String) } + def token_url + end + + # The token URL to be used for this flow. This SHOULD be in the +# form of a URL. +# Valid for oauth2/password, oauth2/application and oauth2/accessCode. + sig { params(value: String).void } + def token_url=(value) + end + + # The token URL to be used for this flow. This SHOULD be in the +# form of a URL. +# Valid for oauth2/password, oauth2/application and oauth2/accessCode. + sig { void } + def clear_token_url + end + + # The available scopes for the OAuth2 security scheme. +# Valid for oauth2. + sig { returns(T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Scopes)) } + def scopes + end + + # The available scopes for the OAuth2 security scheme. +# Valid for oauth2. + sig { params(value: T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::Scopes)).void } + def scopes=(value) + end + + # The available scopes for the OAuth2 security scheme. +# Valid for oauth2. + sig { void } + def clear_scopes + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { returns(T::Hash[String, T.nilable(Google::Protobuf::Value)]) } + def extensions + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { params(value: ::Google::Protobuf::Map).void } + def extensions=(value) + end + + # Custom properties that start with "x-" such as "x-foo" used to describe +# extra functionality that is not covered by the standard OpenAPI Specification. +# See: https://swagger.io/docs/specification/2-0/swagger-extensions/ + sig { void } + def clear_extensions + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `SecurityRequirement` is a representation of OpenAPI v2 specification's +# Security Requirement object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#securityRequirementObject +# +# Lists the required security schemes to execute this operation. The object can +# have multiple security schemes declared in it which are all required (that +# is, there is a logical AND between the schemes). +# +# The name used for each property MUST correspond to a security scheme +# declared in the Security Definitions. +class Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + security_requirement: T.nilable(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement::SecurityRequirementValue)]) + ).void + end + def initialize( + security_requirement: ::Google::Protobuf::Map.new(:string, :message, Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement::SecurityRequirementValue) + ) + end + + # Each name must correspond to a security scheme which is declared in +# the Security Definitions. If the security scheme is of type "oauth2", +# then the value is a list of scope names required for the execution. +# For other security scheme types, the array MUST be empty. + sig { returns(T::Hash[String, T.nilable(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement::SecurityRequirementValue)]) } + def security_requirement + end + + # Each name must correspond to a security scheme which is declared in +# the Security Definitions. If the security scheme is of type "oauth2", +# then the value is a list of scope names required for the execution. +# For other security scheme types, the array MUST be empty. + sig { params(value: ::Google::Protobuf::Map).void } + def security_requirement=(value) + end + + # Each name must correspond to a security scheme which is declared in +# the Security Definitions. If the security scheme is of type "oauth2", +# then the value is a list of scope names required for the execution. +# For other security scheme types, the array MUST be empty. + sig { void } + def clear_security_requirement + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `Scopes` is a representation of OpenAPI v2 specification's Scopes object. +# +# See: https://github.com/OAI/OpenAPI-Specification/blob/3.0.0/versions/2.0.md#scopesObject +# +# Lists the available scopes for an OAuth2 security scheme. +class Grpc::Gateway::ProtocGenOpenapiv2::Options::Scopes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scope: T.nilable(T::Hash[String, String]) + ).void + end + def initialize( + scope: ::Google::Protobuf::Map.new(:string, :string) + ) + end + + # Maps between a name of a scope to a short description of it (as the value +# of the property). + sig { returns(T::Hash[String, String]) } + def scope + end + + # Maps between a name of a scope to a short description of it (as the value +# of the property). + sig { params(value: ::Google::Protobuf::Map).void } + def scope=(value) + end + + # Maps between a name of a scope to a short description of it (as the value +# of the property). + sig { void } + def clear_scope + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::Scopes) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Scopes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::Scopes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::Scopes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# 'FieldConfiguration' provides additional field level properties used when generating the OpenAPI v2 file. +# These properties are not defined by OpenAPIv2, but they are used to control the generation. +class Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::FieldConfiguration + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + path_param_name: T.nilable(String) + ).void + end + def initialize( + path_param_name: "" + ) + end + + # Alternative parameter name when used as path parameter. If set, this will +# be used as the complete parameter name when this field is used as a path +# parameter. Use this to avoid having auto generated path parameter names +# for overlapping paths. + sig { returns(String) } + def path_param_name + end + + # Alternative parameter name when used as path parameter. If set, this will +# be used as the complete parameter name when this field is used as a path +# parameter. Use this to avoid having auto generated path parameter names +# for overlapping paths. + sig { params(value: String).void } + def path_param_name=(value) + end + + # Alternative parameter name when used as path parameter. If set, this will +# be used as the complete parameter name when this field is used as a path +# parameter. Use this to avoid having auto generated path parameter names +# for overlapping paths. + sig { void } + def clear_path_param_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(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::FieldConfiguration) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::FieldConfiguration).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::FieldConfiguration) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::FieldConfiguration, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# If the security scheme is of type "oauth2", then the value is a list of +# scope names required for the execution. For other security scheme types, +# the array MUST be empty. +class Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement::SecurityRequirementValue + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + scope: T.nilable(T::Array[String]) + ).void + end + def initialize( + scope: [] + ) + end + + sig { returns(T::Array[String]) } + def scope + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def scope=(value) + end + + sig { void } + def clear_scope + 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(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement::SecurityRequirementValue) } + def self.decode(str) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement::SecurityRequirementValue).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement::SecurityRequirementValue) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityRequirement::SecurityRequirementValue, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Grpc::Gateway::ProtocGenOpenapiv2::Options::Scheme + self::UNKNOWN = T.let(0, Integer) + self::HTTP = T.let(1, Integer) + self::HTTPS = T.let(2, Integer) + self::WS = T.let(3, Integer) + self::WSS = T.let(4, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Grpc::Gateway::ProtocGenOpenapiv2::Options::HeaderParameter::Type + self::UNKNOWN = T.let(0, Integer) + self::STRING = T.let(1, Integer) + self::NUMBER = T.let(2, Integer) + self::INTEGER = T.let(3, Integer) + self::BOOLEAN = T.let(4, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Grpc::Gateway::ProtocGenOpenapiv2::Options::JSONSchema::JSONSchemaSimpleTypes + self::UNKNOWN = T.let(0, Integer) + self::ARRAY = T.let(1, Integer) + self::BOOLEAN = T.let(2, Integer) + self::INTEGER = T.let(3, Integer) + self::NULL = T.let(4, Integer) + self::NUMBER = T.let(5, Integer) + self::OBJECT = T.let(6, Integer) + self::STRING = T.let(7, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme::Type + self::TYPE_INVALID = T.let(0, Integer) + self::TYPE_BASIC = T.let(1, Integer) + self::TYPE_API_KEY = T.let(2, Integer) + self::TYPE_OAUTH2 = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme::In + self::IN_INVALID = T.let(0, Integer) + self::IN_QUERY = T.let(1, Integer) + self::IN_HEADER = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Grpc::Gateway::ProtocGenOpenapiv2::Options::SecurityScheme::Flow + self::FLOW_INVALID = T.let(0, Integer) + self::FLOW_IMPLICIT = T.let(1, Integer) + self::FLOW_PASSWORD = T.let(2, Integer) + self::FLOW_APPLICATION = T.let(3, Integer) + self::FLOW_ACCESS_CODE = T.let(4, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/protocol/v1/message.rbi b/temporalio/rbi/temporalio/api/protocol/v1/message.rbi new file mode 100644 index 00000000..8f6c69d8 --- /dev/null +++ b/temporalio/rbi/temporalio/api/protocol/v1/message.rbi @@ -0,0 +1,139 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/protocol/v1/message.proto +# typed: strict + +# (-- api-linter: core::0146::any=disabled +# aip.dev/not-precedent: We want runtime extensibility for the body field --) +class Temporalio::Api::Protocol::V1::Message + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + protocol_instance_id: T.nilable(String), + event_id: T.nilable(Integer), + command_index: T.nilable(Integer), + body: T.nilable(Google::Protobuf::Any) + ).void + end + def initialize( + id: "", + protocol_instance_id: "", + event_id: 0, + command_index: 0, + body: nil + ) + end + + # An ID for this specific message. + sig { returns(String) } + def id + end + + # An ID for this specific message. + sig { params(value: String).void } + def id=(value) + end + + # An ID for this specific message. + sig { void } + def clear_id + end + + # Identifies the specific instance of a protocol to which this message +# belongs. + sig { returns(String) } + def protocol_instance_id + end + + # Identifies the specific instance of a protocol to which this message +# belongs. + sig { params(value: String).void } + def protocol_instance_id=(value) + end + + # Identifies the specific instance of a protocol to which this message +# belongs. + sig { void } + def clear_protocol_instance_id + end + + sig { returns(Integer) } + def event_id + end + + sig { params(value: Integer).void } + def event_id=(value) + end + + sig { void } + def clear_event_id + end + + sig { returns(Integer) } + def command_index + end + + sig { params(value: Integer).void } + def command_index=(value) + end + + sig { void } + def clear_command_index + end + + # The opaque data carried by this message. The protocol type can be +# extracted from the package name of the message carried inside the Any. + sig { returns(T.nilable(Google::Protobuf::Any)) } + def body + end + + # The opaque data carried by this message. The protocol type can be +# extracted from the package name of the message carried inside the Any. + sig { params(value: T.nilable(Google::Protobuf::Any)).void } + def body=(value) + end + + # The opaque data carried by this message. The protocol type can be +# extracted from the package name of the message carried inside the Any. + sig { void } + def clear_body + end + + sig { returns(T.nilable(Symbol)) } + def sequencing_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::Protocol::V1::Message) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Protocol::V1::Message).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Protocol::V1::Message) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Protocol::V1::Message, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/protometa/v1/annotations.rbi b/temporalio/rbi/temporalio/api/protometa/v1/annotations.rbi new file mode 100644 index 00000000..23d4e348 --- /dev/null +++ b/temporalio/rbi/temporalio/api/protometa/v1/annotations.rbi @@ -0,0 +1,97 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/protometa/v1/annotations.proto +# typed: strict + +# RequestHeaderAnnotation allows specifying that field values from a request +# should be propagated as outbound headers. +# +# The value field supports template interpolation where field paths enclosed +# in braces will be replaced with the actual field values from the request. +# For example: +# value: "{workflow_execution.workflow_id}" +# value: "workflow-{workflow_execution.workflow_id}" +# value: "{namespace}/{workflow_execution.workflow_id}" +class Temporalio::Api::Protometa::V1::RequestHeaderAnnotation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + header: T.nilable(String), + value: T.nilable(String) + ).void + end + def initialize( + header: "", + value: "" + ) + end + + # The name of the header to set (e.g., "temporal-resource-id") + sig { returns(String) } + def header + end + + # The name of the header to set (e.g., "temporal-resource-id") + sig { params(value: String).void } + def header=(value) + end + + # The name of the header to set (e.g., "temporal-resource-id") + sig { void } + def clear_header + end + + # A template string that may contain field paths in braces. +# Field paths use dot notation to traverse nested messages. +# Example: "{workflow_execution.workflow_id}" + sig { returns(String) } + def value + end + + # A template string that may contain field paths in braces. +# Field paths use dot notation to traverse nested messages. +# Example: "{workflow_execution.workflow_id}" + sig { params(value: String).void } + def value=(value) + end + + # A template string that may contain field paths in braces. +# Field paths use dot notation to traverse nested messages. +# Example: "{workflow_execution.workflow_id}" + sig { void } + def clear_value + 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::Protometa::V1::RequestHeaderAnnotation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Protometa::V1::RequestHeaderAnnotation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Protometa::V1::RequestHeaderAnnotation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Protometa::V1::RequestHeaderAnnotation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/query/v1/message.rbi b/temporalio/rbi/temporalio/api/query/v1/message.rbi new file mode 100644 index 00000000..4f52efb2 --- /dev/null +++ b/temporalio/rbi/temporalio/api/query/v1/message.rbi @@ -0,0 +1,288 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/query/v1/message.proto +# typed: strict + +# See https://docs.temporal.io/docs/concepts/queries/ +class Temporalio::Api::Query::V1::WorkflowQuery + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + query_type: T.nilable(String), + query_args: T.nilable(Temporalio::Api::Common::V1::Payloads), + header: T.nilable(Temporalio::Api::Common::V1::Header) + ).void + end + def initialize( + query_type: "", + query_args: nil, + header: nil + ) + end + + # The workflow-author-defined identifier of the query. Typically a function name. + sig { returns(String) } + def query_type + end + + # The workflow-author-defined identifier of the query. Typically a function name. + sig { params(value: String).void } + def query_type=(value) + end + + # The workflow-author-defined identifier of the query. Typically a function name. + sig { void } + def clear_query_type + end + + # Serialized arguments that will be provided to the query handler. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def query_args + end + + # Serialized arguments that will be provided to the query handler. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def query_args=(value) + end + + # Serialized arguments that will be provided to the query handler. + sig { void } + def clear_query_args + end + + # Headers that were passed by the caller of the query and copied by temporal +# server into the workflow task. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Headers that were passed by the caller of the query and copied by temporal +# server into the workflow task. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Headers that were passed by the caller of the query and copied by temporal +# server into the workflow task. + sig { void } + def clear_header + 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::Query::V1::WorkflowQuery) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Query::V1::WorkflowQuery).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Query::V1::WorkflowQuery) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Query::V1::WorkflowQuery, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Answer to a `WorkflowQuery` +class Temporalio::Api::Query::V1::WorkflowQueryResult + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result_type: T.nilable(T.any(Symbol, String, Integer)), + answer: T.nilable(Temporalio::Api::Common::V1::Payloads), + error_message: T.nilable(String), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + result_type: :QUERY_RESULT_TYPE_UNSPECIFIED, + answer: nil, + error_message: "", + failure: nil + ) + end + + # Did the query succeed or fail? + sig { returns(T.any(Symbol, Integer)) } + def result_type + end + + # Did the query succeed or fail? + sig { params(value: T.any(Symbol, String, Integer)).void } + def result_type=(value) + end + + # Did the query succeed or fail? + sig { void } + def clear_result_type + end + + # Set when the query succeeds with the results. +# Mutually exclusive with `error_message` and `failure`. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def answer + end + + # Set when the query succeeds with the results. +# Mutually exclusive with `error_message` and `failure`. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def answer=(value) + end + + # Set when the query succeeds with the results. +# Mutually exclusive with `error_message` and `failure`. + sig { void } + def clear_answer + end + + # Mutually exclusive with `answer`. Set when the query fails. +# See also the newer `failure` field. + sig { returns(String) } + def error_message + end + + # Mutually exclusive with `answer`. Set when the query fails. +# See also the newer `failure` field. + sig { params(value: String).void } + def error_message=(value) + end + + # Mutually exclusive with `answer`. Set when the query fails. +# See also the newer `failure` field. + sig { void } + def clear_error_message + end + + # The full reason for this query failure. This field is newer than `error_message` and can be encoded by the SDK's +# failure converter to support E2E encryption of messages and stack traces. +# Mutually exclusive with `answer`. Set when the query fails. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The full reason for this query failure. This field is newer than `error_message` and can be encoded by the SDK's +# failure converter to support E2E encryption of messages and stack traces. +# Mutually exclusive with `answer`. Set when the query fails. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The full reason for this query failure. This field is newer than `error_message` and can be encoded by the SDK's +# failure converter to support E2E encryption of messages and stack traces. +# Mutually exclusive with `answer`. Set when the query fails. + sig { void } + def clear_failure + 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::Query::V1::WorkflowQueryResult) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Query::V1::WorkflowQueryResult).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Query::V1::WorkflowQueryResult) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Query::V1::WorkflowQueryResult, 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::Query::V1::QueryRejected + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + status: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + status: :WORKFLOW_EXECUTION_STATUS_UNSPECIFIED + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def status + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + sig { void } + def clear_status + 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::Query::V1::QueryRejected) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Query::V1::QueryRejected).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Query::V1::QueryRejected) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Query::V1::QueryRejected, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/replication/v1/message.rbi b/temporalio/rbi/temporalio/api/replication/v1/message.rbi new file mode 100644 index 00000000..bdee92d9 --- /dev/null +++ b/temporalio/rbi/temporalio/api/replication/v1/message.rbi @@ -0,0 +1,226 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/replication/v1/message.proto +# typed: strict + +class Temporalio::Api::Replication::V1::ClusterReplicationConfig + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cluster_name: T.nilable(String) + ).void + end + def initialize( + cluster_name: "" + ) + end + + sig { returns(String) } + def cluster_name + end + + sig { params(value: String).void } + def cluster_name=(value) + end + + sig { void } + def clear_cluster_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::Replication::V1::ClusterReplicationConfig) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Replication::V1::ClusterReplicationConfig).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Replication::V1::ClusterReplicationConfig) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Replication::V1::ClusterReplicationConfig, 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::Replication::V1::NamespaceReplicationConfig + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + active_cluster_name: T.nilable(String), + clusters: T.nilable(T::Array[T.nilable(Temporalio::Api::Replication::V1::ClusterReplicationConfig)]), + state: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + active_cluster_name: "", + clusters: [], + state: :REPLICATION_STATE_UNSPECIFIED + ) + end + + sig { returns(String) } + def active_cluster_name + end + + sig { params(value: String).void } + def active_cluster_name=(value) + end + + sig { void } + def clear_active_cluster_name + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Replication::V1::ClusterReplicationConfig)]) } + def clusters + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def clusters=(value) + end + + sig { void } + def clear_clusters + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + 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::Replication::V1::NamespaceReplicationConfig) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Replication::V1::NamespaceReplicationConfig).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Replication::V1::NamespaceReplicationConfig) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Replication::V1::NamespaceReplicationConfig, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Represents a historical replication status of a Namespace +class Temporalio::Api::Replication::V1::FailoverStatus + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failover_time: T.nilable(Google::Protobuf::Timestamp), + failover_version: T.nilable(Integer) + ).void + end + def initialize( + failover_time: nil, + failover_version: 0 + ) + end + + # Timestamp when the Cluster switched to the following failover_version + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def failover_time + end + + # Timestamp when the Cluster switched to the following failover_version + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def failover_time=(value) + end + + # Timestamp when the Cluster switched to the following failover_version + sig { void } + def clear_failover_time + end + + sig { returns(Integer) } + def failover_version + end + + sig { params(value: Integer).void } + def failover_version=(value) + end + + sig { void } + def clear_failover_version + 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::Replication::V1::FailoverStatus) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Replication::V1::FailoverStatus).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Replication::V1::FailoverStatus) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Replication::V1::FailoverStatus, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/rules/v1/message.rbi b/temporalio/rbi/temporalio/api/rules/v1/message.rbi new file mode 100644 index 00000000..63d717ce --- /dev/null +++ b/temporalio/rbi/temporalio/api/rules/v1/message.rbi @@ -0,0 +1,492 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/rules/v1/message.proto +# typed: strict + +class Temporalio::Api::Rules::V1::WorkflowRuleAction + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_pause: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleAction::ActionActivityPause) + ).void + end + def initialize( + activity_pause: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleAction::ActionActivityPause)) } + def activity_pause + end + + sig { params(value: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleAction::ActionActivityPause)).void } + def activity_pause=(value) + end + + sig { void } + def clear_activity_pause + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Rules::V1::WorkflowRuleAction) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRuleAction).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Rules::V1::WorkflowRuleAction) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRuleAction, 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::Rules::V1::WorkflowRuleSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + activity_start: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec::ActivityStartingTrigger), + visibility_query: T.nilable(String), + actions: T.nilable(T::Array[T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleAction)]), + expiration_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + id: "", + activity_start: nil, + visibility_query: "", + actions: [], + expiration_time: nil + ) + end + + # The id of the new workflow rule. Must be unique within the namespace. +# Can be set by the user, and can have business meaning. + sig { returns(String) } + def id + end + + # The id of the new workflow rule. Must be unique within the namespace. +# Can be set by the user, and can have business meaning. + sig { params(value: String).void } + def id=(value) + end + + # The id of the new workflow rule. Must be unique within the namespace. +# Can be set by the user, and can have business meaning. + sig { void } + def clear_id + end + + sig { returns(T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec::ActivityStartingTrigger)) } + def activity_start + end + + sig { params(value: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec::ActivityStartingTrigger)).void } + def activity_start=(value) + end + + sig { void } + def clear_activity_start + end + + # Restricted Visibility query. +# This query is used to filter workflows in this namespace to which this rule should apply. +# It is applied to any running workflow each time a triggering event occurs, before the trigger predicate is evaluated. +# The following workflow attributes are supported: +# - WorkflowType +# - WorkflowId +# - StartTime +# - ExecutionStatus + sig { returns(String) } + def visibility_query + end + + # Restricted Visibility query. +# This query is used to filter workflows in this namespace to which this rule should apply. +# It is applied to any running workflow each time a triggering event occurs, before the trigger predicate is evaluated. +# The following workflow attributes are supported: +# - WorkflowType +# - WorkflowId +# - StartTime +# - ExecutionStatus + sig { params(value: String).void } + def visibility_query=(value) + end + + # Restricted Visibility query. +# This query is used to filter workflows in this namespace to which this rule should apply. +# It is applied to any running workflow each time a triggering event occurs, before the trigger predicate is evaluated. +# The following workflow attributes are supported: +# - WorkflowType +# - WorkflowId +# - StartTime +# - ExecutionStatus + sig { void } + def clear_visibility_query + end + + # WorkflowRuleAction to be taken when the rule is triggered and predicate is matched. + sig { returns(T::Array[T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleAction)]) } + def actions + end + + # WorkflowRuleAction to be taken when the rule is triggered and predicate is matched. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def actions=(value) + end + + # WorkflowRuleAction to be taken when the rule is triggered and predicate is matched. + sig { void } + def clear_actions + end + + # Expiration time of the rule. After this time, the rule will be deleted. +# Can be empty if the rule should never expire. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def expiration_time + end + + # Expiration time of the rule. After this time, the rule will be deleted. +# Can be empty if the rule should never expire. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def expiration_time=(value) + end + + # Expiration time of the rule. After this time, the rule will be deleted. +# Can be empty if the rule should never expire. + sig { void } + def clear_expiration_time + end + + sig { returns(T.nilable(Symbol)) } + def trigger + 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::Rules::V1::WorkflowRuleSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRuleSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Rules::V1::WorkflowRuleSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRuleSpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# WorkflowRule describes a rule that can be applied to any workflow in this namespace. +class Temporalio::Api::Rules::V1::WorkflowRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + create_time: T.nilable(Google::Protobuf::Timestamp), + spec: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec), + created_by_identity: T.nilable(String), + description: T.nilable(String) + ).void + end + def initialize( + create_time: nil, + spec: nil, + created_by_identity: "", + description: "" + ) + end + + # Rule creation time. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def create_time + end + + # Rule creation time. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def create_time=(value) + end + + # Rule creation time. + sig { void } + def clear_create_time + end + + # Rule specification + sig { returns(T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec)) } + def spec + end + + # Rule specification + sig { params(value: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec)).void } + def spec=(value) + end + + # Rule specification + sig { void } + def clear_spec + end + + # Identity of the actor that created the rule +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: It is better reflect the intent this way, we will also have updated_by. --) +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Same as above. All other options sounds clumsy --) + sig { returns(String) } + def created_by_identity + end + + # Identity of the actor that created the rule +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: It is better reflect the intent this way, we will also have updated_by. --) +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Same as above. All other options sounds clumsy --) + sig { params(value: String).void } + def created_by_identity=(value) + end + + # Identity of the actor that created the rule +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: It is better reflect the intent this way, we will also have updated_by. --) +# (-- api-linter: core::0142::time-field-names=disabled +# aip.dev/not-precedent: Same as above. All other options sounds clumsy --) + sig { void } + def clear_created_by_identity + end + + # Rule description. + sig { returns(String) } + def description + end + + # Rule description. + sig { params(value: String).void } + def description=(value) + end + + # Rule description. + sig { void } + def clear_description + 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::Rules::V1::WorkflowRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Rules::V1::WorkflowRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRule, 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::Rules::V1::WorkflowRuleAction::ActionActivityPause + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Rules::V1::WorkflowRuleAction::ActionActivityPause) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRuleAction::ActionActivityPause).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Rules::V1::WorkflowRuleAction::ActionActivityPause) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRuleAction::ActionActivityPause, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Activity trigger will be triggered when an activity is about to start. +class Temporalio::Api::Rules::V1::WorkflowRuleSpec::ActivityStartingTrigger + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + predicate: T.nilable(String) + ).void + end + def initialize( + predicate: "" + ) + end + + # Activity predicate is a SQL-like string filter parameter. +# It is used to match against workflow data. +# The following activity attributes are supported as part of the predicate: +# - ActivityType: An Activity Type is the mapping of a name to an Activity Definition.. +# - ActivityId: The ID of the activity. +# - ActivityAttempt: The number attempts of the activity. +# - BackoffInterval: The current amount of time between scheduled attempts of the activity. +# - ActivityStatus: The status of the activity. Can be one of "Scheduled", "Started", "Paused". +# - TaskQueue: The name of the task queue the workflow specified that the activity should run on. +# Activity predicate support the following operators: +# * =, !=, >, >=, <, <= +# * AND, OR, () +# * BETWEEN ... AND +# STARTS_WITH + sig { returns(String) } + def predicate + end + + # Activity predicate is a SQL-like string filter parameter. +# It is used to match against workflow data. +# The following activity attributes are supported as part of the predicate: +# - ActivityType: An Activity Type is the mapping of a name to an Activity Definition.. +# - ActivityId: The ID of the activity. +# - ActivityAttempt: The number attempts of the activity. +# - BackoffInterval: The current amount of time between scheduled attempts of the activity. +# - ActivityStatus: The status of the activity. Can be one of "Scheduled", "Started", "Paused". +# - TaskQueue: The name of the task queue the workflow specified that the activity should run on. +# Activity predicate support the following operators: +# * =, !=, >, >=, <, <= +# * AND, OR, () +# * BETWEEN ... AND +# STARTS_WITH + sig { params(value: String).void } + def predicate=(value) + end + + # Activity predicate is a SQL-like string filter parameter. +# It is used to match against workflow data. +# The following activity attributes are supported as part of the predicate: +# - ActivityType: An Activity Type is the mapping of a name to an Activity Definition.. +# - ActivityId: The ID of the activity. +# - ActivityAttempt: The number attempts of the activity. +# - BackoffInterval: The current amount of time between scheduled attempts of the activity. +# - ActivityStatus: The status of the activity. Can be one of "Scheduled", "Started", "Paused". +# - TaskQueue: The name of the task queue the workflow specified that the activity should run on. +# Activity predicate support the following operators: +# * =, !=, >, >=, <, <= +# * AND, OR, () +# * BETWEEN ... AND +# STARTS_WITH + sig { void } + def clear_predicate + 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::Rules::V1::WorkflowRuleSpec::ActivityStartingTrigger) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRuleSpec::ActivityStartingTrigger).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Rules::V1::WorkflowRuleSpec::ActivityStartingTrigger) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Rules::V1::WorkflowRuleSpec::ActivityStartingTrigger, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/schedule/v1/message.rbi b/temporalio/rbi/temporalio/api/schedule/v1/message.rbi new file mode 100644 index 00000000..4f33629c --- /dev/null +++ b/temporalio/rbi/temporalio/api/schedule/v1/message.rbi @@ -0,0 +1,2343 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/schedule/v1/message.proto +# typed: strict + +# CalendarSpec describes an event specification relative to the calendar, +# similar to a traditional cron specification, but with labeled fields. Each +# field can be one of: +# *: matches always +# x: matches when the field equals x +# x/y : matches when the field equals x+n*y where n is an integer +# x-z: matches when the field is between x and z inclusive +# w,x,y,...: matches when the field is one of the listed values +# Each x, y, z, ... is either a decimal integer, or a month or day of week name +# or abbreviation (in the appropriate fields). +# A timestamp matches if all fields match. +# Note that fields have different default values, for convenience. +# Note that the special case that some cron implementations have for treating +# day_of_month and day_of_week as "or" instead of "and" when both are set is +# not implemented. +# day_of_week can accept 0 or 7 as Sunday +# CalendarSpec gets compiled into StructuredCalendarSpec, which is what will be +# returned if you describe the schedule. +class Temporalio::Api::Schedule::V1::CalendarSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + second: T.nilable(String), + minute: T.nilable(String), + hour: T.nilable(String), + day_of_month: T.nilable(String), + month: T.nilable(String), + year: T.nilable(String), + day_of_week: T.nilable(String), + comment: T.nilable(String) + ).void + end + def initialize( + second: "", + minute: "", + hour: "", + day_of_month: "", + month: "", + year: "", + day_of_week: "", + comment: "" + ) + end + + # Expression to match seconds. Default: 0 + sig { returns(String) } + def second + end + + # Expression to match seconds. Default: 0 + sig { params(value: String).void } + def second=(value) + end + + # Expression to match seconds. Default: 0 + sig { void } + def clear_second + end + + # Expression to match minutes. Default: 0 + sig { returns(String) } + def minute + end + + # Expression to match minutes. Default: 0 + sig { params(value: String).void } + def minute=(value) + end + + # Expression to match minutes. Default: 0 + sig { void } + def clear_minute + end + + # Expression to match hours. Default: 0 + sig { returns(String) } + def hour + end + + # Expression to match hours. Default: 0 + sig { params(value: String).void } + def hour=(value) + end + + # Expression to match hours. Default: 0 + sig { void } + def clear_hour + end + + # Expression to match days of the month. Default: * +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: standard name of field --) + sig { returns(String) } + def day_of_month + end + + # Expression to match days of the month. Default: * +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: standard name of field --) + sig { params(value: String).void } + def day_of_month=(value) + end + + # Expression to match days of the month. Default: * +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: standard name of field --) + sig { void } + def clear_day_of_month + end + + # Expression to match months. Default: * + sig { returns(String) } + def month + end + + # Expression to match months. Default: * + sig { params(value: String).void } + def month=(value) + end + + # Expression to match months. Default: * + sig { void } + def clear_month + end + + # Expression to match years. Default: * + sig { returns(String) } + def year + end + + # Expression to match years. Default: * + sig { params(value: String).void } + def year=(value) + end + + # Expression to match years. Default: * + sig { void } + def clear_year + end + + # Expression to match days of the week. Default: * + sig { returns(String) } + def day_of_week + end + + # Expression to match days of the week. Default: * + sig { params(value: String).void } + def day_of_week=(value) + end + + # Expression to match days of the week. Default: * + sig { void } + def clear_day_of_week + end + + # Free-form comment describing the intention of this spec. + sig { returns(String) } + def comment + end + + # Free-form comment describing the intention of this spec. + sig { params(value: String).void } + def comment=(value) + end + + # Free-form comment describing the intention of this spec. + sig { void } + def clear_comment + 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::Schedule::V1::CalendarSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::CalendarSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::CalendarSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::CalendarSpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Range represents a set of integer values, used to match fields of a calendar +# time in StructuredCalendarSpec. If end < start, then end is interpreted as +# equal to start. This means you can use a Range with start set to a value, and +# end and step unset (defaulting to 0) to represent a single value. +class Temporalio::Api::Schedule::V1::Range + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start: T.nilable(Integer), + end: T.nilable(Integer), + step: T.nilable(Integer) + ).void + end + def initialize( + start: 0, + end: 0, + step: 0 + ) + end + + # Start of range (inclusive). + sig { returns(Integer) } + def start + end + + # Start of range (inclusive). + sig { params(value: Integer).void } + def start=(value) + end + + # Start of range (inclusive). + sig { void } + def clear_start + end + + # End of range (inclusive). + sig { returns(Integer) } + def end + end + + # End of range (inclusive). + sig { params(value: Integer).void } + def end=(value) + end + + # End of range (inclusive). + sig { void } + def clear_end + end + + # Step (optional, default 1). + sig { returns(Integer) } + def step + end + + # Step (optional, default 1). + sig { params(value: Integer).void } + def step=(value) + end + + # Step (optional, default 1). + sig { void } + def clear_step + 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::Schedule::V1::Range) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::Range).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::Range) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::Range, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# StructuredCalendarSpec describes an event specification relative to the +# calendar, in a form that's easy to work with programmatically. Each field can +# be one or more ranges. +# A timestamp matches if at least one range of each field matches the +# corresponding fields of the timestamp, except for year: if year is missing, +# that means all years match. For all fields besides year, at least one Range +# must be present to match anything. +# Relative expressions such as "last day of the month" or "third Monday" are not currently +# representable; callers must enumerate the concrete days they require. +class Temporalio::Api::Schedule::V1::StructuredCalendarSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + second: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]), + minute: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]), + hour: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]), + day_of_month: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]), + month: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]), + year: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]), + day_of_week: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]), + comment: T.nilable(String) + ).void + end + def initialize( + second: [], + minute: [], + hour: [], + day_of_month: [], + month: [], + year: [], + day_of_week: [], + comment: "" + ) + end + + # Match seconds (0-59) + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]) } + def second + end + + # Match seconds (0-59) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def second=(value) + end + + # Match seconds (0-59) + sig { void } + def clear_second + end + + # Match minutes (0-59) + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]) } + def minute + end + + # Match minutes (0-59) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def minute=(value) + end + + # Match minutes (0-59) + sig { void } + def clear_minute + end + + # Match hours (0-23) + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]) } + def hour + end + + # Match hours (0-23) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def hour=(value) + end + + # Match hours (0-23) + sig { void } + def clear_hour + end + + # Match days of the month (1-31) +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: standard name of field --) + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]) } + def day_of_month + end + + # Match days of the month (1-31) +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: standard name of field --) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def day_of_month=(value) + end + + # Match days of the month (1-31) +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: standard name of field --) + sig { void } + def clear_day_of_month + end + + # Match months (1-12) + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]) } + def month + end + + # Match months (1-12) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def month=(value) + end + + # Match months (1-12) + sig { void } + def clear_month + end + + # Match years. + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]) } + def year + end + + # Match years. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def year=(value) + end + + # Match years. + sig { void } + def clear_year + end + + # Match days of the week (0-6; 0 is Sunday). + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::Range)]) } + def day_of_week + end + + # Match days of the week (0-6; 0 is Sunday). + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def day_of_week=(value) + end + + # Match days of the week (0-6; 0 is Sunday). + sig { void } + def clear_day_of_week + end + + # Free-form comment describing the intention of this spec. + sig { returns(String) } + def comment + end + + # Free-form comment describing the intention of this spec. + sig { params(value: String).void } + def comment=(value) + end + + # Free-form comment describing the intention of this spec. + sig { void } + def clear_comment + 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::Schedule::V1::StructuredCalendarSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::StructuredCalendarSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::StructuredCalendarSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::StructuredCalendarSpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# IntervalSpec matches times that can be expressed as: +# epoch + n * interval + phase +# where n is an integer. +# phase defaults to zero if missing. interval is required. +# Both interval and phase must be non-negative and are truncated to the nearest +# second before any calculations. +# For example, an interval of 1 hour with phase of zero would match every hour, +# on the hour. The same interval but a phase of 19 minutes would match every +# xx:19:00. An interval of 28 days with phase zero would match +# 2022-02-17T00:00:00Z (among other times). The same interval with a phase of 3 +# days, 5 hours, and 23 minutes would match 2022-02-20T05:23:00Z instead. +class Temporalio::Api::Schedule::V1::IntervalSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + interval: T.nilable(Google::Protobuf::Duration), + phase: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + interval: nil, + phase: nil + ) + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def interval + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def interval=(value) + end + + sig { void } + def clear_interval + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def phase + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def phase=(value) + end + + sig { void } + def clear_phase + 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::Schedule::V1::IntervalSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::IntervalSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::IntervalSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::IntervalSpec, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# ScheduleSpec is a complete description of a set of absolute timestamps +# (possibly infinite) that an action should occur at. The meaning of a +# ScheduleSpec depends only on its contents and never changes, except that the +# definition of a time zone can change over time (most commonly, when daylight +# saving time policy changes for an area). To create a totally self-contained +# ScheduleSpec, use UTC or include timezone_data. +# +# For input, you can provide zero or more of: structured_calendar, calendar, +# cron_string, interval, and exclude_structured_calendar, and all of them will +# be used (the schedule will take action at the union of all of their times, +# minus the ones that match exclude_structured_calendar). +# +# On input, calendar and cron_string fields will be compiled into +# structured_calendar (and maybe interval and timezone_name), so if you +# Describe a schedule, you'll see only structured_calendar, interval, etc. +# +# If a spec has no matching times after the current time, then the schedule +# will be subject to automatic deletion (after several days). +class Temporalio::Api::Schedule::V1::ScheduleSpec + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + structured_calendar: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::StructuredCalendarSpec)]), + cron_string: T.nilable(T::Array[String]), + calendar: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::CalendarSpec)]), + interval: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::IntervalSpec)]), + exclude_calendar: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::CalendarSpec)]), + exclude_structured_calendar: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::StructuredCalendarSpec)]), + start_time: T.nilable(Google::Protobuf::Timestamp), + end_time: T.nilable(Google::Protobuf::Timestamp), + jitter: T.nilable(Google::Protobuf::Duration), + timezone_name: T.nilable(String), + timezone_data: T.nilable(String) + ).void + end + def initialize( + structured_calendar: [], + cron_string: [], + calendar: [], + interval: [], + exclude_calendar: [], + exclude_structured_calendar: [], + start_time: nil, + end_time: nil, + jitter: nil, + timezone_name: "", + timezone_data: "" + ) + end + + # Calendar-based specifications of times. + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::StructuredCalendarSpec)]) } + def structured_calendar + end + + # Calendar-based specifications of times. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def structured_calendar=(value) + end + + # Calendar-based specifications of times. + sig { void } + def clear_structured_calendar + end + + # cron_string holds a traditional cron specification as a string. It +# accepts 5, 6, or 7 fields, separated by spaces, and interprets them the +# same way as CalendarSpec. +# 5 fields: minute, hour, day_of_month, month, day_of_week +# 6 fields: minute, hour, day_of_month, month, day_of_week, year +# 7 fields: second, minute, hour, day_of_month, month, day_of_week, year +# If year is not given, it defaults to *. If second is not given, it +# defaults to 0. +# Shorthands @yearly, @monthly, @weekly, @daily, and @hourly are also +# accepted instead of the 5-7 time fields. +# Optionally, the string can be preceded by CRON_TZ= or +# TZ=, which will get copied to timezone_name. (There must +# not also be a timezone_name present.) +# Optionally "#" followed by a comment can appear at the end of the string. +# Note that the special case that some cron implementations have for +# treating day_of_month and day_of_week as "or" instead of "and" when both +# are set is not implemented. +# @every [/] is accepted and gets compiled into an +# IntervalSpec instead. and should be a decimal integer +# with a unit suffix s, m, h, or d. + sig { returns(T::Array[String]) } + def cron_string + end + + # cron_string holds a traditional cron specification as a string. It +# accepts 5, 6, or 7 fields, separated by spaces, and interprets them the +# same way as CalendarSpec. +# 5 fields: minute, hour, day_of_month, month, day_of_week +# 6 fields: minute, hour, day_of_month, month, day_of_week, year +# 7 fields: second, minute, hour, day_of_month, month, day_of_week, year +# If year is not given, it defaults to *. If second is not given, it +# defaults to 0. +# Shorthands @yearly, @monthly, @weekly, @daily, and @hourly are also +# accepted instead of the 5-7 time fields. +# Optionally, the string can be preceded by CRON_TZ= or +# TZ=, which will get copied to timezone_name. (There must +# not also be a timezone_name present.) +# Optionally "#" followed by a comment can appear at the end of the string. +# Note that the special case that some cron implementations have for +# treating day_of_month and day_of_week as "or" instead of "and" when both +# are set is not implemented. +# @every [/] is accepted and gets compiled into an +# IntervalSpec instead. and should be a decimal integer +# with a unit suffix s, m, h, or d. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def cron_string=(value) + end + + # cron_string holds a traditional cron specification as a string. It +# accepts 5, 6, or 7 fields, separated by spaces, and interprets them the +# same way as CalendarSpec. +# 5 fields: minute, hour, day_of_month, month, day_of_week +# 6 fields: minute, hour, day_of_month, month, day_of_week, year +# 7 fields: second, minute, hour, day_of_month, month, day_of_week, year +# If year is not given, it defaults to *. If second is not given, it +# defaults to 0. +# Shorthands @yearly, @monthly, @weekly, @daily, and @hourly are also +# accepted instead of the 5-7 time fields. +# Optionally, the string can be preceded by CRON_TZ= or +# TZ=, which will get copied to timezone_name. (There must +# not also be a timezone_name present.) +# Optionally "#" followed by a comment can appear at the end of the string. +# Note that the special case that some cron implementations have for +# treating day_of_month and day_of_week as "or" instead of "and" when both +# are set is not implemented. +# @every [/] is accepted and gets compiled into an +# IntervalSpec instead. and should be a decimal integer +# with a unit suffix s, m, h, or d. + sig { void } + def clear_cron_string + end + + # Calendar-based specifications of times. + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::CalendarSpec)]) } + def calendar + end + + # Calendar-based specifications of times. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def calendar=(value) + end + + # Calendar-based specifications of times. + sig { void } + def clear_calendar + end + + # Interval-based specifications of times. + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::IntervalSpec)]) } + def interval + end + + # Interval-based specifications of times. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def interval=(value) + end + + # Interval-based specifications of times. + sig { void } + def clear_interval + end + + # Any timestamps matching any of exclude_* will be skipped. +# Deprecated. Use exclude_structured_calendar. + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::CalendarSpec)]) } + def exclude_calendar + end + + # Any timestamps matching any of exclude_* will be skipped. +# Deprecated. Use exclude_structured_calendar. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def exclude_calendar=(value) + end + + # Any timestamps matching any of exclude_* will be skipped. +# Deprecated. Use exclude_structured_calendar. + sig { void } + def clear_exclude_calendar + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::StructuredCalendarSpec)]) } + def exclude_structured_calendar + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def exclude_structured_calendar=(value) + end + + sig { void } + def clear_exclude_structured_calendar + end + + # If start_time is set, any timestamps before start_time will be skipped. +# (Together, start_time and end_time make an inclusive interval.) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # If start_time is set, any timestamps before start_time will be skipped. +# (Together, start_time and end_time make an inclusive interval.) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # If start_time is set, any timestamps before start_time will be skipped. +# (Together, start_time and end_time make an inclusive interval.) + sig { void } + def clear_start_time + end + + # If end_time is set, any timestamps after end_time will be skipped. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def end_time + end + + # If end_time is set, any timestamps after end_time will be skipped. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def end_time=(value) + end + + # If end_time is set, any timestamps after end_time will be skipped. + sig { void } + def clear_end_time + end + + # All timestamps will be incremented by a random value from 0 to this +# amount of jitter. Default: 0 + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def jitter + end + + # All timestamps will be incremented by a random value from 0 to this +# amount of jitter. Default: 0 + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def jitter=(value) + end + + # All timestamps will be incremented by a random value from 0 to this +# amount of jitter. Default: 0 + sig { void } + def clear_jitter + end + + # Time zone to interpret all calendar-based specs in. +# +# If unset, defaults to UTC. We recommend using UTC for your application if +# at all possible, to avoid various surprising properties of time zones. +# +# Time zones may be provided by name, corresponding to names in the IANA +# time zone database (see https://www.iana.org/time-zones). The definition +# will be loaded by the Temporal server from the environment it runs in. +# +# If your application requires more control over the time zone definition +# used, it may pass in a complete definition in the form of a TZif file +# from the time zone database. If present, this will be used instead of +# loading anything from the environment. You are then responsible for +# updating timezone_data when the definition changes. +# +# Calendar spec matching is based on literal matching of the clock time +# with no special handling of DST: if you write a calendar spec that fires +# at 2:30am and specify a time zone that follows DST, that action will not +# be triggered on the day that has no 2:30am. Similarly, an action that +# fires at 1:30am will be triggered twice on the day that has two 1:30s. +# +# Also note that no actions are taken on leap-seconds (e.g. 23:59:60 UTC). + sig { returns(String) } + def timezone_name + end + + # Time zone to interpret all calendar-based specs in. +# +# If unset, defaults to UTC. We recommend using UTC for your application if +# at all possible, to avoid various surprising properties of time zones. +# +# Time zones may be provided by name, corresponding to names in the IANA +# time zone database (see https://www.iana.org/time-zones). The definition +# will be loaded by the Temporal server from the environment it runs in. +# +# If your application requires more control over the time zone definition +# used, it may pass in a complete definition in the form of a TZif file +# from the time zone database. If present, this will be used instead of +# loading anything from the environment. You are then responsible for +# updating timezone_data when the definition changes. +# +# Calendar spec matching is based on literal matching of the clock time +# with no special handling of DST: if you write a calendar spec that fires +# at 2:30am and specify a time zone that follows DST, that action will not +# be triggered on the day that has no 2:30am. Similarly, an action that +# fires at 1:30am will be triggered twice on the day that has two 1:30s. +# +# Also note that no actions are taken on leap-seconds (e.g. 23:59:60 UTC). + sig { params(value: String).void } + def timezone_name=(value) + end + + # Time zone to interpret all calendar-based specs in. +# +# If unset, defaults to UTC. We recommend using UTC for your application if +# at all possible, to avoid various surprising properties of time zones. +# +# Time zones may be provided by name, corresponding to names in the IANA +# time zone database (see https://www.iana.org/time-zones). The definition +# will be loaded by the Temporal server from the environment it runs in. +# +# If your application requires more control over the time zone definition +# used, it may pass in a complete definition in the form of a TZif file +# from the time zone database. If present, this will be used instead of +# loading anything from the environment. You are then responsible for +# updating timezone_data when the definition changes. +# +# Calendar spec matching is based on literal matching of the clock time +# with no special handling of DST: if you write a calendar spec that fires +# at 2:30am and specify a time zone that follows DST, that action will not +# be triggered on the day that has no 2:30am. Similarly, an action that +# fires at 1:30am will be triggered twice on the day that has two 1:30s. +# +# Also note that no actions are taken on leap-seconds (e.g. 23:59:60 UTC). + sig { void } + def clear_timezone_name + end + + sig { returns(String) } + def timezone_data + end + + sig { params(value: String).void } + def timezone_data=(value) + end + + sig { void } + def clear_timezone_data + 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::Schedule::V1::ScheduleSpec) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleSpec).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::ScheduleSpec) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleSpec, 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::Schedule::V1::SchedulePolicies + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + overlap_policy: T.nilable(T.any(Symbol, String, Integer)), + catchup_window: T.nilable(Google::Protobuf::Duration), + pause_on_failure: T.nilable(T::Boolean), + keep_original_workflow_id: T.nilable(T::Boolean) + ).void + end + def initialize( + overlap_policy: :SCHEDULE_OVERLAP_POLICY_UNSPECIFIED, + catchup_window: nil, + pause_on_failure: false, + keep_original_workflow_id: false + ) + end + + # Policy for overlaps. +# Note that this can be changed after a schedule has taken some actions, +# and some changes might produce unintuitive results. In general, the later +# policy overrides the earlier policy. + sig { returns(T.any(Symbol, Integer)) } + def overlap_policy + end + + # Policy for overlaps. +# Note that this can be changed after a schedule has taken some actions, +# and some changes might produce unintuitive results. In general, the later +# policy overrides the earlier policy. + sig { params(value: T.any(Symbol, String, Integer)).void } + def overlap_policy=(value) + end + + # Policy for overlaps. +# Note that this can be changed after a schedule has taken some actions, +# and some changes might produce unintuitive results. In general, the later +# policy overrides the earlier policy. + sig { void } + def clear_overlap_policy + end + + # Policy for catchups: +# If the Temporal server misses an action due to one or more components +# being down, and comes back up, the action will be run if the scheduled +# time is within this window from the current time. +# This value defaults to one year, and can't be less than 10 seconds. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def catchup_window + end + + # Policy for catchups: +# If the Temporal server misses an action due to one or more components +# being down, and comes back up, the action will be run if the scheduled +# time is within this window from the current time. +# This value defaults to one year, and can't be less than 10 seconds. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def catchup_window=(value) + end + + # Policy for catchups: +# If the Temporal server misses an action due to one or more components +# being down, and comes back up, the action will be run if the scheduled +# time is within this window from the current time. +# This value defaults to one year, and can't be less than 10 seconds. + sig { void } + def clear_catchup_window + end + + # If true, and a workflow run fails or times out, turn on "paused". +# This applies after retry policies: the full chain of retries must fail to +# trigger a pause here. + sig { returns(T::Boolean) } + def pause_on_failure + end + + # If true, and a workflow run fails or times out, turn on "paused". +# This applies after retry policies: the full chain of retries must fail to +# trigger a pause here. + sig { params(value: T::Boolean).void } + def pause_on_failure=(value) + end + + # If true, and a workflow run fails or times out, turn on "paused". +# This applies after retry policies: the full chain of retries must fail to +# trigger a pause here. + sig { void } + def clear_pause_on_failure + end + + # If true, and the action would start a workflow, a timestamp will not be +# appended to the scheduled workflow id. + sig { returns(T::Boolean) } + def keep_original_workflow_id + end + + # If true, and the action would start a workflow, a timestamp will not be +# appended to the scheduled workflow id. + sig { params(value: T::Boolean).void } + def keep_original_workflow_id=(value) + end + + # If true, and the action would start a workflow, a timestamp will not be +# appended to the scheduled workflow id. + sig { void } + def clear_keep_original_workflow_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::Schedule::V1::SchedulePolicies) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::SchedulePolicies).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::SchedulePolicies) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::SchedulePolicies, 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::Schedule::V1::ScheduleAction + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_workflow: T.nilable(Temporalio::Api::Workflow::V1::NewWorkflowExecutionInfo) + ).void + end + def initialize( + start_workflow: nil + ) + end + + # All fields of NewWorkflowExecutionInfo are valid except for: +# - workflow_id_reuse_policy +# - cron_schedule +# The workflow id of the started workflow may not match this exactly, +# it may have a timestamp appended for uniqueness. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::NewWorkflowExecutionInfo)) } + def start_workflow + end + + # All fields of NewWorkflowExecutionInfo are valid except for: +# - workflow_id_reuse_policy +# - cron_schedule +# The workflow id of the started workflow may not match this exactly, +# it may have a timestamp appended for uniqueness. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::NewWorkflowExecutionInfo)).void } + def start_workflow=(value) + end + + # All fields of NewWorkflowExecutionInfo are valid except for: +# - workflow_id_reuse_policy +# - cron_schedule +# The workflow id of the started workflow may not match this exactly, +# it may have a timestamp appended for uniqueness. + sig { void } + def clear_start_workflow + end + + sig { returns(T.nilable(Symbol)) } + def action + 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::Schedule::V1::ScheduleAction) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleAction).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::ScheduleAction) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleAction, 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::Schedule::V1::ScheduleActionResult + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + schedule_time: T.nilable(Google::Protobuf::Timestamp), + actual_time: T.nilable(Google::Protobuf::Timestamp), + start_workflow_result: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + start_workflow_status: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + schedule_time: nil, + actual_time: nil, + start_workflow_result: nil, + start_workflow_status: :WORKFLOW_EXECUTION_STATUS_UNSPECIFIED + ) + end + + # Time that the action was taken (according to the schedule, including jitter). + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def schedule_time + end + + # Time that the action was taken (according to the schedule, including jitter). + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def schedule_time=(value) + end + + # Time that the action was taken (according to the schedule, including jitter). + sig { void } + def clear_schedule_time + end + + # Time that the action was taken (real time). + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def actual_time + end + + # Time that the action was taken (real time). + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def actual_time=(value) + end + + # Time that the action was taken (real time). + sig { void } + def clear_actual_time + end + + # If action was start_workflow: + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def start_workflow_result + end + + # If action was start_workflow: + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def start_workflow_result=(value) + end + + # If action was start_workflow: + sig { void } + def clear_start_workflow_result + end + + # If the action was start_workflow, this field will reflect an +# eventually-consistent view of the started workflow's status. + sig { returns(T.any(Symbol, Integer)) } + def start_workflow_status + end + + # If the action was start_workflow, this field will reflect an +# eventually-consistent view of the started workflow's status. + sig { params(value: T.any(Symbol, String, Integer)).void } + def start_workflow_status=(value) + end + + # If the action was start_workflow, this field will reflect an +# eventually-consistent view of the started workflow's status. + sig { void } + def clear_start_workflow_status + 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::Schedule::V1::ScheduleActionResult) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleActionResult).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::ScheduleActionResult) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleActionResult, 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::Schedule::V1::ScheduleState + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + notes: T.nilable(String), + paused: T.nilable(T::Boolean), + limited_actions: T.nilable(T::Boolean), + remaining_actions: T.nilable(Integer) + ).void + end + def initialize( + notes: "", + paused: false, + limited_actions: false, + remaining_actions: 0 + ) + end + + # Informative human-readable message with contextual notes, e.g. the reason +# a schedule is paused. The system may overwrite this message on certain +# conditions, e.g. when pause-on-failure happens. + sig { returns(String) } + def notes + end + + # Informative human-readable message with contextual notes, e.g. the reason +# a schedule is paused. The system may overwrite this message on certain +# conditions, e.g. when pause-on-failure happens. + sig { params(value: String).void } + def notes=(value) + end + + # Informative human-readable message with contextual notes, e.g. the reason +# a schedule is paused. The system may overwrite this message on certain +# conditions, e.g. when pause-on-failure happens. + sig { void } + def clear_notes + end + + # If true, do not take any actions based on the schedule spec. + sig { returns(T::Boolean) } + def paused + end + + # If true, do not take any actions based on the schedule spec. + sig { params(value: T::Boolean).void } + def paused=(value) + end + + # If true, do not take any actions based on the schedule spec. + sig { void } + def clear_paused + end + + # If limited_actions is true, decrement remaining_actions after each +# action, and do not take any more scheduled actions if remaining_actions +# is zero. Actions may still be taken by explicit request (i.e. trigger +# immediately or backfill). Skipped actions (due to overlap policy) do not +# count against remaining actions. +# If a schedule has no more remaining actions, then the schedule will be +# subject to automatic deletion (after several days). + sig { returns(T::Boolean) } + def limited_actions + end + + # If limited_actions is true, decrement remaining_actions after each +# action, and do not take any more scheduled actions if remaining_actions +# is zero. Actions may still be taken by explicit request (i.e. trigger +# immediately or backfill). Skipped actions (due to overlap policy) do not +# count against remaining actions. +# If a schedule has no more remaining actions, then the schedule will be +# subject to automatic deletion (after several days). + sig { params(value: T::Boolean).void } + def limited_actions=(value) + end + + # If limited_actions is true, decrement remaining_actions after each +# action, and do not take any more scheduled actions if remaining_actions +# is zero. Actions may still be taken by explicit request (i.e. trigger +# immediately or backfill). Skipped actions (due to overlap policy) do not +# count against remaining actions. +# If a schedule has no more remaining actions, then the schedule will be +# subject to automatic deletion (after several days). + sig { void } + def clear_limited_actions + end + + sig { returns(Integer) } + def remaining_actions + end + + sig { params(value: Integer).void } + def remaining_actions=(value) + end + + sig { void } + def clear_remaining_actions + 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::Schedule::V1::ScheduleState) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleState).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::ScheduleState) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleState, 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::Schedule::V1::TriggerImmediatelyRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + overlap_policy: T.nilable(T.any(Symbol, String, Integer)), + scheduled_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + overlap_policy: :SCHEDULE_OVERLAP_POLICY_UNSPECIFIED, + scheduled_time: nil + ) + end + + # If set, override overlap policy for this one request. + sig { returns(T.any(Symbol, Integer)) } + def overlap_policy + end + + # If set, override overlap policy for this one request. + sig { params(value: T.any(Symbol, String, Integer)).void } + def overlap_policy=(value) + end + + # If set, override overlap policy for this one request. + sig { void } + def clear_overlap_policy + end + + # Timestamp used for the identity of the target workflow. +# If not set the default value is the current time. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def scheduled_time + end + + # Timestamp used for the identity of the target workflow. +# If not set the default value is the current time. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def scheduled_time=(value) + end + + # Timestamp used for the identity of the target workflow. +# If not set the default value is the current time. + sig { void } + def clear_scheduled_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::Schedule::V1::TriggerImmediatelyRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::TriggerImmediatelyRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::TriggerImmediatelyRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::TriggerImmediatelyRequest, 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::Schedule::V1::BackfillRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_time: T.nilable(Google::Protobuf::Timestamp), + end_time: T.nilable(Google::Protobuf::Timestamp), + overlap_policy: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + start_time: nil, + end_time: nil, + overlap_policy: :SCHEDULE_OVERLAP_POLICY_UNSPECIFIED + ) + end + + # Time range to evaluate schedule in. Currently, this time range is +# exclusive on start_time and inclusive on end_time. (This is admittedly +# counterintuitive and it may change in the future, so to be safe, use a +# start time strictly before a scheduled time.) Also note that an action +# nominally scheduled in the interval but with jitter that pushes it after +# end_time will not be included. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # Time range to evaluate schedule in. Currently, this time range is +# exclusive on start_time and inclusive on end_time. (This is admittedly +# counterintuitive and it may change in the future, so to be safe, use a +# start time strictly before a scheduled time.) Also note that an action +# nominally scheduled in the interval but with jitter that pushes it after +# end_time will not be included. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # Time range to evaluate schedule in. Currently, this time range is +# exclusive on start_time and inclusive on end_time. (This is admittedly +# counterintuitive and it may change in the future, so to be safe, use a +# start time strictly before a scheduled time.) Also note that an action +# nominally scheduled in the interval but with jitter that pushes it after +# end_time will not be included. + sig { void } + def clear_start_time + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def end_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def end_time=(value) + end + + sig { void } + def clear_end_time + end + + # If set, override overlap policy for this request. + sig { returns(T.any(Symbol, Integer)) } + def overlap_policy + end + + # If set, override overlap policy for this request. + sig { params(value: T.any(Symbol, String, Integer)).void } + def overlap_policy=(value) + end + + # If set, override overlap policy for this request. + sig { void } + def clear_overlap_policy + 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::Schedule::V1::BackfillRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::BackfillRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::BackfillRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::BackfillRequest, 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::Schedule::V1::SchedulePatch + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + 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) + ).void + end + def initialize( + trigger_immediately: nil, + backfill_request: [], + pause: "", + unpause: "" + ) + end + + # If set, trigger one action immediately. + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::TriggerImmediatelyRequest)) } + def trigger_immediately + end + + # If set, trigger one action immediately. + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::TriggerImmediatelyRequest)).void } + def trigger_immediately=(value) + end + + # If set, trigger one action immediately. + sig { void } + def clear_trigger_immediately + end + + # If set, runs though the specified time period(s) and takes actions as if that time +# passed by right now, all at once. The overlap policy can be overridden for the +# scope of the backfill. + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::BackfillRequest)]) } + def backfill_request + end + + # If set, runs though the specified time period(s) and takes actions as if that time +# passed by right now, all at once. The overlap policy can be overridden for the +# scope of the backfill. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def backfill_request=(value) + end + + # If set, runs though the specified time period(s) and takes actions as if that time +# passed by right now, all at once. The overlap policy can be overridden for the +# scope of the backfill. + sig { void } + def clear_backfill_request + end + + # If set, change the state to paused or unpaused (respectively) and set the +# notes field to the value of the string. + sig { returns(String) } + def pause + end + + # If set, change the state to paused or unpaused (respectively) and set the +# notes field to the value of the string. + sig { params(value: String).void } + def pause=(value) + end + + # If set, change the state to paused or unpaused (respectively) and set the +# notes field to the value of the string. + sig { void } + def clear_pause + end + + sig { returns(String) } + def unpause + end + + sig { params(value: String).void } + def unpause=(value) + end + + sig { void } + def clear_unpause + 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::Schedule::V1::SchedulePatch) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::SchedulePatch).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::SchedulePatch) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::SchedulePatch, 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::Schedule::V1::ScheduleInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + action_count: T.nilable(Integer), + missed_catchup_window: T.nilable(Integer), + overlap_skipped: T.nilable(Integer), + buffer_dropped: T.nilable(Integer), + buffer_size: T.nilable(Integer), + running_workflows: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)]), + recent_actions: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::ScheduleActionResult)]), + future_action_times: T.nilable(T::Array[T.nilable(Google::Protobuf::Timestamp)]), + create_time: T.nilable(Google::Protobuf::Timestamp), + update_time: T.nilable(Google::Protobuf::Timestamp), + invalid_schedule_error: T.nilable(String) + ).void + end + def initialize( + action_count: 0, + missed_catchup_window: 0, + overlap_skipped: 0, + buffer_dropped: 0, + buffer_size: 0, + running_workflows: [], + recent_actions: [], + future_action_times: [], + create_time: nil, + update_time: nil, + invalid_schedule_error: "" + ) + end + + # Number of actions taken so far. + sig { returns(Integer) } + def action_count + end + + # Number of actions taken so far. + sig { params(value: Integer).void } + def action_count=(value) + end + + # Number of actions taken so far. + sig { void } + def clear_action_count + end + + # Number of times a scheduled action was skipped due to missing the catchup window. + sig { returns(Integer) } + def missed_catchup_window + end + + # Number of times a scheduled action was skipped due to missing the catchup window. + sig { params(value: Integer).void } + def missed_catchup_window=(value) + end + + # Number of times a scheduled action was skipped due to missing the catchup window. + sig { void } + def clear_missed_catchup_window + end + + # Number of skipped actions due to overlap. + sig { returns(Integer) } + def overlap_skipped + end + + # Number of skipped actions due to overlap. + sig { params(value: Integer).void } + def overlap_skipped=(value) + end + + # Number of skipped actions due to overlap. + sig { void } + def clear_overlap_skipped + end + + # Number of dropped actions due to buffer limit. + sig { returns(Integer) } + def buffer_dropped + end + + # Number of dropped actions due to buffer limit. + sig { params(value: Integer).void } + def buffer_dropped=(value) + end + + # Number of dropped actions due to buffer limit. + sig { void } + def clear_buffer_dropped + end + + # Number of actions in the buffer. The buffer holds the actions that cannot +# be immediately triggered (due to the overlap policy). These actions can be a result of +# the normal schedule or a backfill. + sig { returns(Integer) } + def buffer_size + end + + # Number of actions in the buffer. The buffer holds the actions that cannot +# be immediately triggered (due to the overlap policy). These actions can be a result of +# the normal schedule or a backfill. + sig { params(value: Integer).void } + def buffer_size=(value) + end + + # Number of actions in the buffer. The buffer holds the actions that cannot +# be immediately triggered (due to the overlap policy). These actions can be a result of +# the normal schedule or a backfill. + sig { void } + def clear_buffer_size + end + + # Currently-running workflows started by this schedule. (There might be +# more than one if the overlap policy allows overlaps.) +# Note that the run_ids in here are the original execution run ids as +# started by the schedule. If the workflows retried, did continue-as-new, +# or were reset, they might still be running but with a different run_id. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)]) } + def running_workflows + end + + # Currently-running workflows started by this schedule. (There might be +# more than one if the overlap policy allows overlaps.) +# Note that the run_ids in here are the original execution run ids as +# started by the schedule. If the workflows retried, did continue-as-new, +# or were reset, they might still be running but with a different run_id. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def running_workflows=(value) + end + + # Currently-running workflows started by this schedule. (There might be +# more than one if the overlap policy allows overlaps.) +# Note that the run_ids in here are the original execution run ids as +# started by the schedule. If the workflows retried, did continue-as-new, +# or were reset, they might still be running but with a different run_id. + sig { void } + def clear_running_workflows + end + + # Most recent ten actual action times (including manual triggers). + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::ScheduleActionResult)]) } + def recent_actions + end + + # Most recent ten actual action times (including manual triggers). + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def recent_actions=(value) + end + + # Most recent ten actual action times (including manual triggers). + sig { void } + def clear_recent_actions + end + + # Next ten scheduled action times. + sig { returns(T::Array[T.nilable(Google::Protobuf::Timestamp)]) } + def future_action_times + end + + # Next ten scheduled action times. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def future_action_times=(value) + end + + # Next ten scheduled action times. + sig { void } + def clear_future_action_times + end + + # Timestamps of schedule creation and last update. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def create_time + end + + # Timestamps of schedule creation and last update. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def create_time=(value) + end + + # Timestamps of schedule creation and last update. + sig { void } + def clear_create_time + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def update_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def update_time=(value) + end + + sig { void } + def clear_update_time + end + + # Deprecated. + sig { returns(String) } + def invalid_schedule_error + end + + # Deprecated. + sig { params(value: String).void } + def invalid_schedule_error=(value) + end + + # Deprecated. + sig { void } + def clear_invalid_schedule_error + 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::Schedule::V1::ScheduleInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::ScheduleInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleInfo, 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::Schedule::V1::Schedule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Schedule::V1::ScheduleSpec), + action: T.nilable(Temporalio::Api::Schedule::V1::ScheduleAction), + policies: T.nilable(Temporalio::Api::Schedule::V1::SchedulePolicies), + state: T.nilable(Temporalio::Api::Schedule::V1::ScheduleState) + ).void + end + def initialize( + spec: nil, + action: nil, + policies: nil, + state: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::ScheduleSpec)) } + def spec + end + + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::ScheduleSpec)).void } + def spec=(value) + end + + sig { void } + def clear_spec + end + + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::ScheduleAction)) } + def action + end + + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::ScheduleAction)).void } + def action=(value) + end + + sig { void } + def clear_action + end + + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::SchedulePolicies)) } + def policies + end + + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::SchedulePolicies)).void } + def policies=(value) + end + + sig { void } + def clear_policies + end + + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::ScheduleState)) } + def state + end + + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::ScheduleState)).void } + def state=(value) + end + + sig { void } + def clear_state + 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::Schedule::V1::Schedule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::Schedule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::Schedule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::Schedule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# ScheduleListInfo is an abbreviated set of values from Schedule and ScheduleInfo +# that's returned in ListSchedules. +class Temporalio::Api::Schedule::V1::ScheduleListInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + spec: T.nilable(Temporalio::Api::Schedule::V1::ScheduleSpec), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + notes: T.nilable(String), + paused: T.nilable(T::Boolean), + recent_actions: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::ScheduleActionResult)]), + future_action_times: T.nilable(T::Array[T.nilable(Google::Protobuf::Timestamp)]) + ).void + end + def initialize( + spec: nil, + workflow_type: nil, + notes: "", + paused: false, + recent_actions: [], + future_action_times: [] + ) + end + + # From spec: +# Some fields are dropped from this copy of spec: timezone_data + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::ScheduleSpec)) } + def spec + end + + # From spec: +# Some fields are dropped from this copy of spec: timezone_data + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::ScheduleSpec)).void } + def spec=(value) + end + + # From spec: +# Some fields are dropped from this copy of spec: timezone_data + sig { void } + def clear_spec + end + + # From action: +# Action is a oneof field, but we need to encode this in JSON and oneof fields don't work +# well with JSON. If action is start_workflow, this is set: + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + # From action: +# Action is a oneof field, but we need to encode this in JSON and oneof fields don't work +# well with JSON. If action is start_workflow, this is set: + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + # From action: +# Action is a oneof field, but we need to encode this in JSON and oneof fields don't work +# well with JSON. If action is start_workflow, this is set: + sig { void } + def clear_workflow_type + end + + # From state: + sig { returns(String) } + def notes + end + + # From state: + sig { params(value: String).void } + def notes=(value) + end + + # From state: + sig { void } + def clear_notes + end + + sig { returns(T::Boolean) } + def paused + end + + sig { params(value: T::Boolean).void } + def paused=(value) + end + + sig { void } + def clear_paused + end + + # From info (maybe fewer entries): + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::ScheduleActionResult)]) } + def recent_actions + end + + # From info (maybe fewer entries): + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def recent_actions=(value) + end + + # From info (maybe fewer entries): + sig { void } + def clear_recent_actions + end + + sig { returns(T::Array[T.nilable(Google::Protobuf::Timestamp)]) } + def future_action_times + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def future_action_times=(value) + end + + sig { void } + def clear_future_action_times + 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::Schedule::V1::ScheduleListInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleListInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::ScheduleListInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleListInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# ScheduleListEntry is returned by ListSchedules. +class Temporalio::Api::Schedule::V1::ScheduleListEntry + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + schedule_id: T.nilable(String), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + info: T.nilable(Temporalio::Api::Schedule::V1::ScheduleListInfo) + ).void + end + def initialize( + schedule_id: "", + memo: nil, + search_attributes: nil, + info: nil + ) + end + + sig { returns(String) } + def schedule_id + end + + sig { params(value: String).void } + def schedule_id=(value) + end + + sig { void } + def clear_schedule_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::ScheduleListInfo)) } + def info + end + + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::ScheduleListInfo)).void } + def info=(value) + end + + sig { void } + def clear_info + 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::Schedule::V1::ScheduleListEntry) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleListEntry).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Schedule::V1::ScheduleListEntry) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Schedule::V1::ScheduleListEntry, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/sdk/v1/enhanced_stack_trace.rbi b/temporalio/rbi/temporalio/api/sdk/v1/enhanced_stack_trace.rbi new file mode 100644 index 00000000..d5f4bd0c --- /dev/null +++ b/temporalio/rbi/temporalio/api/sdk/v1/enhanced_stack_trace.rbi @@ -0,0 +1,478 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/sdk/v1/enhanced_stack_trace.proto +# typed: strict + +# Internal structure used to create worker stack traces with references to code. +class Temporalio::Api::Sdk::V1::EnhancedStackTrace + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + sdk: T.nilable(Temporalio::Api::Sdk::V1::StackTraceSDKInfo), + sources: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Sdk::V1::StackTraceFileSlice)]), + stacks: T.nilable(T::Array[T.nilable(Temporalio::Api::Sdk::V1::StackTrace)]) + ).void + end + def initialize( + sdk: nil, + sources: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Sdk::V1::StackTraceFileSlice), + stacks: [] + ) + end + + # Information pertaining to the SDK that the trace has been captured from. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::StackTraceSDKInfo)) } + def sdk + end + + # Information pertaining to the SDK that the trace has been captured from. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::StackTraceSDKInfo)).void } + def sdk=(value) + end + + # Information pertaining to the SDK that the trace has been captured from. + sig { void } + def clear_sdk + end + + # Mapping of file path to file contents. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Sdk::V1::StackTraceFileSlice)]) } + def sources + end + + # Mapping of file path to file contents. + sig { params(value: ::Google::Protobuf::Map).void } + def sources=(value) + end + + # Mapping of file path to file contents. + sig { void } + def clear_sources + end + + # Collection of stacks captured. + sig { returns(T::Array[T.nilable(Temporalio::Api::Sdk::V1::StackTrace)]) } + def stacks + end + + # Collection of stacks captured. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def stacks=(value) + end + + # Collection of stacks captured. + sig { void } + def clear_stacks + 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::Sdk::V1::EnhancedStackTrace) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::EnhancedStackTrace).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::EnhancedStackTrace) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::EnhancedStackTrace, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Information pertaining to the SDK that the trace has been captured from. +# (-- api-linter: core::0123::resource-annotation=disabled +# aip.dev/not-precedent: Naming SDK version is optional. --) +class Temporalio::Api::Sdk::V1::StackTraceSDKInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + version: T.nilable(String) + ).void + end + def initialize( + name: "", + version: "" + ) + end + + # Name of the SDK + sig { returns(String) } + def name + end + + # Name of the SDK + sig { params(value: String).void } + def name=(value) + end + + # Name of the SDK + sig { void } + def clear_name + end + + # Version string of the SDK + sig { returns(String) } + def version + end + + # Version string of the SDK + sig { params(value: String).void } + def version=(value) + end + + # Version string of the SDK + sig { void } + def clear_version + 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::Sdk::V1::StackTraceSDKInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::StackTraceSDKInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::StackTraceSDKInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::StackTraceSDKInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# "Slice" of a file starting at line_offset -- a line offset and code fragment corresponding to the worker's stack. +class Temporalio::Api::Sdk::V1::StackTraceFileSlice + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + line_offset: T.nilable(Integer), + content: T.nilable(String) + ).void + end + def initialize( + line_offset: 0, + content: "" + ) + end + + # Only used (possibly) to trim the file without breaking syntax highlighting. This is not optional, unlike +# the `line` property of a `StackTraceFileLocation`. +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { returns(Integer) } + def line_offset + end + + # Only used (possibly) to trim the file without breaking syntax highlighting. This is not optional, unlike +# the `line` property of a `StackTraceFileLocation`. +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { params(value: Integer).void } + def line_offset=(value) + end + + # Only used (possibly) to trim the file without breaking syntax highlighting. This is not optional, unlike +# the `line` property of a `StackTraceFileLocation`. +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { void } + def clear_line_offset + end + + # Slice of a file with the respective OS-specific line terminator. + sig { returns(String) } + def content + end + + # Slice of a file with the respective OS-specific line terminator. + sig { params(value: String).void } + def content=(value) + end + + # Slice of a file with the respective OS-specific line terminator. + sig { void } + def clear_content + 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::Sdk::V1::StackTraceFileSlice) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::StackTraceFileSlice).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::StackTraceFileSlice) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::StackTraceFileSlice, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# More specific location details of a file: its path, precise line and column numbers if applicable, and function name if available. +# In essence, a pointer to a location in a file +class Temporalio::Api::Sdk::V1::StackTraceFileLocation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + file_path: T.nilable(String), + line: T.nilable(Integer), + column: T.nilable(Integer), + function_name: T.nilable(String), + internal_code: T.nilable(T::Boolean) + ).void + end + def initialize( + file_path: "", + line: 0, + column: 0, + function_name: "", + internal_code: false + ) + end + + # Path to source file (absolute or relative). +# If the paths are relative, ensure that they are all relative to the same root. + sig { returns(String) } + def file_path + end + + # Path to source file (absolute or relative). +# If the paths are relative, ensure that they are all relative to the same root. + sig { params(value: String).void } + def file_path=(value) + end + + # Path to source file (absolute or relative). +# If the paths are relative, ensure that they are all relative to the same root. + sig { void } + def clear_file_path + end + + # Optional; If possible, SDK should send this -- this is required for displaying the code location. +# If not provided, set to -1. + sig { returns(Integer) } + def line + end + + # Optional; If possible, SDK should send this -- this is required for displaying the code location. +# If not provided, set to -1. + sig { params(value: Integer).void } + def line=(value) + end + + # Optional; If possible, SDK should send this -- this is required for displaying the code location. +# If not provided, set to -1. + sig { void } + def clear_line + end + + # Optional; if possible, SDK should send this. +# If not provided, set to -1. + sig { returns(Integer) } + def column + end + + # Optional; if possible, SDK should send this. +# If not provided, set to -1. + sig { params(value: Integer).void } + def column=(value) + end + + # Optional; if possible, SDK should send this. +# If not provided, set to -1. + sig { void } + def clear_column + end + + # Function name this line belongs to, if applicable. +# Used for falling back to stack trace view. + sig { returns(String) } + def function_name + end + + # Function name this line belongs to, if applicable. +# Used for falling back to stack trace view. + sig { params(value: String).void } + def function_name=(value) + end + + # Function name this line belongs to, if applicable. +# Used for falling back to stack trace view. + sig { void } + def clear_function_name + end + + # Flag to communicate whether a location should be hidden by default in the stack view. + sig { returns(T::Boolean) } + def internal_code + end + + # Flag to communicate whether a location should be hidden by default in the stack view. + sig { params(value: T::Boolean).void } + def internal_code=(value) + end + + # Flag to communicate whether a location should be hidden by default in the stack view. + sig { void } + def clear_internal_code + 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::Sdk::V1::StackTraceFileLocation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::StackTraceFileLocation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::StackTraceFileLocation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::StackTraceFileLocation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Collection of FileLocation messages from a single stack. +class Temporalio::Api::Sdk::V1::StackTrace + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + locations: T.nilable(T::Array[T.nilable(Temporalio::Api::Sdk::V1::StackTraceFileLocation)]) + ).void + end + def initialize( + locations: [] + ) + end + + # Collection of `FileLocation`s, each for a stack frame that comprise a stack trace. + sig { returns(T::Array[T.nilable(Temporalio::Api::Sdk::V1::StackTraceFileLocation)]) } + def locations + end + + # Collection of `FileLocation`s, each for a stack frame that comprise a stack trace. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def locations=(value) + end + + # Collection of `FileLocation`s, each for a stack frame that comprise a stack trace. + sig { void } + def clear_locations + 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::Sdk::V1::StackTrace) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::StackTrace).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::StackTrace) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::StackTrace, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/sdk/v1/external_storage.rbi b/temporalio/rbi/temporalio/api/sdk/v1/external_storage.rbi new file mode 100644 index 00000000..503b1a96 --- /dev/null +++ b/temporalio/rbi/temporalio/api/sdk/v1/external_storage.rbi @@ -0,0 +1,85 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/sdk/v1/external_storage.proto +# typed: strict + +# ExternalStorageReference identifies a payload stored in an external storage system. +# It is used as a claim-check token, allowing the actual payload data to be retrieved +# from the named driver using the provided claim data. +class Temporalio::Api::Sdk::V1::ExternalStorageReference + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + driver_name: T.nilable(String), + claim_data: T.nilable(T::Hash[String, String]) + ).void + end + def initialize( + driver_name: "", + claim_data: ::Google::Protobuf::Map.new(:string, :string) + ) + end + + # The name of the storage driver responsible for retrieving the payload. + sig { returns(String) } + def driver_name + end + + # The name of the storage driver responsible for retrieving the payload. + sig { params(value: String).void } + def driver_name=(value) + end + + # The name of the storage driver responsible for retrieving the payload. + sig { void } + def clear_driver_name + end + + # Driver-specific key-value pairs that identify and provide access to the stored payload. + sig { returns(T::Hash[String, String]) } + def claim_data + end + + # Driver-specific key-value pairs that identify and provide access to the stored payload. + sig { params(value: ::Google::Protobuf::Map).void } + def claim_data=(value) + end + + # Driver-specific key-value pairs that identify and provide access to the stored payload. + sig { void } + def clear_claim_data + 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::Sdk::V1::ExternalStorageReference) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::ExternalStorageReference).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::ExternalStorageReference) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::ExternalStorageReference, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/sdk/v1/task_complete_metadata.rbi b/temporalio/rbi/temporalio/api/sdk/v1/task_complete_metadata.rbi new file mode 100644 index 00000000..a7c2a490 --- /dev/null +++ b/temporalio/rbi/temporalio/api/sdk/v1/task_complete_metadata.rbi @@ -0,0 +1,206 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/sdk/v1/task_complete_metadata.proto +# typed: strict + +class Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + core_used_flags: T.nilable(T::Array[Integer]), + lang_used_flags: T.nilable(T::Array[Integer]), + sdk_name: T.nilable(String), + sdk_version: T.nilable(String) + ).void + end + def initialize( + core_used_flags: [], + lang_used_flags: [], + sdk_name: "", + sdk_version: "" + ) + end + + # Internal flags used by the core SDK. SDKs using flags must comply with the following behavior: +# +# During replay: +# * If a flag is not recognized (value is too high or not defined), it must fail the workflow +# task. +# * If a flag is recognized, it is stored in a set of used flags for the run. Code checks for +# that flag during and after this WFT are allowed to assume that the flag is present. +# * If a code check for a flag does not find the flag in the set of used flags, it must take +# the branch corresponding to the absence of that flag. +# +# During non-replay execution of new WFTs: +# * The SDK is free to use all flags it knows about. It must record any newly-used (IE: not +# previously recorded) flags when completing the WFT. +# +# SDKs which are too old to even know about this field at all are considered to produce +# undefined behavior if they replay workflows which used this mechanism. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { returns(T::Array[Integer]) } + def core_used_flags + end + + # Internal flags used by the core SDK. SDKs using flags must comply with the following behavior: +# +# During replay: +# * If a flag is not recognized (value is too high or not defined), it must fail the workflow +# task. +# * If a flag is recognized, it is stored in a set of used flags for the run. Code checks for +# that flag during and after this WFT are allowed to assume that the flag is present. +# * If a code check for a flag does not find the flag in the set of used flags, it must take +# the branch corresponding to the absence of that flag. +# +# During non-replay execution of new WFTs: +# * The SDK is free to use all flags it knows about. It must record any newly-used (IE: not +# previously recorded) flags when completing the WFT. +# +# SDKs which are too old to even know about this field at all are considered to produce +# undefined behavior if they replay workflows which used this mechanism. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def core_used_flags=(value) + end + + # Internal flags used by the core SDK. SDKs using flags must comply with the following behavior: +# +# During replay: +# * If a flag is not recognized (value is too high or not defined), it must fail the workflow +# task. +# * If a flag is recognized, it is stored in a set of used flags for the run. Code checks for +# that flag during and after this WFT are allowed to assume that the flag is present. +# * If a code check for a flag does not find the flag in the set of used flags, it must take +# the branch corresponding to the absence of that flag. +# +# During non-replay execution of new WFTs: +# * The SDK is free to use all flags it knows about. It must record any newly-used (IE: not +# previously recorded) flags when completing the WFT. +# +# SDKs which are too old to even know about this field at all are considered to produce +# undefined behavior if they replay workflows which used this mechanism. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { void } + def clear_core_used_flags + end + + # Flags used by the SDK lang. No attempt is made to distinguish between different SDK languages +# here as processing a workflow with a different language than the one which authored it is +# already undefined behavior. See `core_used_patches` for more. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { returns(T::Array[Integer]) } + def lang_used_flags + end + + # Flags used by the SDK lang. No attempt is made to distinguish between different SDK languages +# here as processing a workflow with a different language than the one which authored it is +# already undefined behavior. See `core_used_patches` for more. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def lang_used_flags=(value) + end + + # Flags used by the SDK lang. No attempt is made to distinguish between different SDK languages +# here as processing a workflow with a different language than the one which authored it is +# already undefined behavior. See `core_used_patches` for more. +# +# (-- api-linter: core::0141::forbidden-types=disabled +# aip.dev/not-precedent: These really shouldn't have negative values. --) + sig { void } + def clear_lang_used_flags + end + + # Name of the SDK that processed the task. This is usually something like "temporal-go" and is +# usually the same as client-name gRPC header. This should only be set if its value changed +# since the last time recorded on the workflow (or be set on the first task). +# +# (-- api-linter: core::0122::name-suffix=disabled +# aip.dev/not-precedent: We're ok with a name suffix here. --) + sig { returns(String) } + def sdk_name + end + + # Name of the SDK that processed the task. This is usually something like "temporal-go" and is +# usually the same as client-name gRPC header. This should only be set if its value changed +# since the last time recorded on the workflow (or be set on the first task). +# +# (-- api-linter: core::0122::name-suffix=disabled +# aip.dev/not-precedent: We're ok with a name suffix here. --) + sig { params(value: String).void } + def sdk_name=(value) + end + + # Name of the SDK that processed the task. This is usually something like "temporal-go" and is +# usually the same as client-name gRPC header. This should only be set if its value changed +# since the last time recorded on the workflow (or be set on the first task). +# +# (-- api-linter: core::0122::name-suffix=disabled +# aip.dev/not-precedent: We're ok with a name suffix here. --) + sig { void } + def clear_sdk_name + end + + # Version of the SDK that processed the task. This is usually something like "1.20.0" and is +# usually the same as client-version gRPC header. This should only be set if its value changed +# since the last time recorded on the workflow (or be set on the first task). + sig { returns(String) } + def sdk_version + end + + # Version of the SDK that processed the task. This is usually something like "1.20.0" and is +# usually the same as client-version gRPC header. This should only be set if its value changed +# since the last time recorded on the workflow (or be set on the first task). + sig { params(value: String).void } + def sdk_version=(value) + end + + # Version of the SDK that processed the task. This is usually something like "1.20.0" and is +# usually the same as client-version gRPC header. This should only be set if its value changed +# since the last time recorded on the workflow (or be set on the first task). + sig { void } + def clear_sdk_version + 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::Sdk::V1::WorkflowTaskCompletedMetadata) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/sdk/v1/user_metadata.rbi b/temporalio/rbi/temporalio/api/sdk/v1/user_metadata.rbi new file mode 100644 index 00000000..e3197021 --- /dev/null +++ b/temporalio/rbi/temporalio/api/sdk/v1/user_metadata.rbi @@ -0,0 +1,98 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/sdk/v1/user_metadata.proto +# typed: strict + +# Information a user can set, often for use by user interfaces. +class Temporalio::Api::Sdk::V1::UserMetadata + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + summary: T.nilable(Temporalio::Api::Common::V1::Payload), + details: T.nilable(Temporalio::Api::Common::V1::Payload) + ).void + end + def initialize( + summary: nil, + details: nil + ) + end + + # Short-form text that provides a summary. This payload should be a "json/plain"-encoded payload +# that is a single JSON string for use in user interfaces. User interface formatting may not +# apply to this text when used in "title" situations. The payload data section is limited to 400 +# bytes by default. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def summary + end + + # Short-form text that provides a summary. This payload should be a "json/plain"-encoded payload +# that is a single JSON string for use in user interfaces. User interface formatting may not +# apply to this text when used in "title" situations. The payload data section is limited to 400 +# bytes by default. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def summary=(value) + end + + # Short-form text that provides a summary. This payload should be a "json/plain"-encoded payload +# that is a single JSON string for use in user interfaces. User interface formatting may not +# apply to this text when used in "title" situations. The payload data section is limited to 400 +# bytes by default. + sig { void } + def clear_summary + end + + # Long-form text that provides details. This payload should be a "json/plain"-encoded payload +# that is a single JSON string for use in user interfaces. User interface formatting may apply to +# this text in common use. The payload data section is limited to 20000 bytes by default. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def details + end + + # Long-form text that provides details. This payload should be a "json/plain"-encoded payload +# that is a single JSON string for use in user interfaces. User interface formatting may apply to +# this text in common use. The payload data section is limited to 20000 bytes by default. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def details=(value) + end + + # Long-form text that provides details. This payload should be a "json/plain"-encoded payload +# that is a single JSON string for use in user interfaces. User interface formatting may apply to +# this text in common use. The payload data section is limited to 20000 bytes by default. + sig { void } + def clear_details + 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::Sdk::V1::UserMetadata) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::UserMetadata).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::UserMetadata) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::UserMetadata, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/sdk/v1/worker_config.rbi b/temporalio/rbi/temporalio/api/sdk/v1/worker_config.rbi new file mode 100644 index 00000000..345913be --- /dev/null +++ b/temporalio/rbi/temporalio/api/sdk/v1/worker_config.rbi @@ -0,0 +1,255 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/sdk/v1/worker_config.proto +# typed: strict + +class Temporalio::Api::Sdk::V1::WorkerConfig + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_cache_size: T.nilable(Integer), + simple_poller_behavior: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig::SimplePollerBehavior), + autoscaling_poller_behavior: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig::AutoscalingPollerBehavior) + ).void + end + def initialize( + workflow_cache_size: 0, + simple_poller_behavior: nil, + autoscaling_poller_behavior: nil + ) + end + + sig { returns(Integer) } + def workflow_cache_size + end + + sig { params(value: Integer).void } + def workflow_cache_size=(value) + end + + sig { void } + def clear_workflow_cache_size + end + + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig::SimplePollerBehavior)) } + def simple_poller_behavior + end + + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig::SimplePollerBehavior)).void } + def simple_poller_behavior=(value) + end + + sig { void } + def clear_simple_poller_behavior + end + + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig::AutoscalingPollerBehavior)) } + def autoscaling_poller_behavior + end + + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig::AutoscalingPollerBehavior)).void } + def autoscaling_poller_behavior=(value) + end + + sig { void } + def clear_autoscaling_poller_behavior + end + + sig { returns(T.nilable(Symbol)) } + def poller_behavior + 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::Sdk::V1::WorkerConfig) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkerConfig).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::WorkerConfig) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkerConfig, 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::Sdk::V1::WorkerConfig::SimplePollerBehavior + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + max_pollers: T.nilable(Integer) + ).void + end + def initialize( + max_pollers: 0 + ) + end + + sig { returns(Integer) } + def max_pollers + end + + sig { params(value: Integer).void } + def max_pollers=(value) + end + + sig { void } + def clear_max_pollers + 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::Sdk::V1::WorkerConfig::SimplePollerBehavior) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkerConfig::SimplePollerBehavior).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::WorkerConfig::SimplePollerBehavior) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkerConfig::SimplePollerBehavior, 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::Sdk::V1::WorkerConfig::AutoscalingPollerBehavior + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + min_pollers: T.nilable(Integer), + max_pollers: T.nilable(Integer), + initial_pollers: T.nilable(Integer) + ).void + end + def initialize( + min_pollers: 0, + max_pollers: 0, + initial_pollers: 0 + ) + end + + # At least this many poll calls will always be attempted (assuming slots are available). +# Cannot be zero. + sig { returns(Integer) } + def min_pollers + end + + # At least this many poll calls will always be attempted (assuming slots are available). +# Cannot be zero. + sig { params(value: Integer).void } + def min_pollers=(value) + end + + # At least this many poll calls will always be attempted (assuming slots are available). +# Cannot be zero. + sig { void } + def clear_min_pollers + end + + # At most this many poll calls will ever be open at once. Must be >= `minimum`. + sig { returns(Integer) } + def max_pollers + end + + # At most this many poll calls will ever be open at once. Must be >= `minimum`. + sig { params(value: Integer).void } + def max_pollers=(value) + end + + # At most this many poll calls will ever be open at once. Must be >= `minimum`. + sig { void } + def clear_max_pollers + end + + # This many polls will be attempted initially before scaling kicks in. Must be between +# `minimum` and `maximum`. + sig { returns(Integer) } + def initial_pollers + end + + # This many polls will be attempted initially before scaling kicks in. Must be between +# `minimum` and `maximum`. + sig { params(value: Integer).void } + def initial_pollers=(value) + end + + # This many polls will be attempted initially before scaling kicks in. Must be between +# `minimum` and `maximum`. + sig { void } + def clear_initial_pollers + 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::Sdk::V1::WorkerConfig::AutoscalingPollerBehavior) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkerConfig::AutoscalingPollerBehavior).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::WorkerConfig::AutoscalingPollerBehavior) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkerConfig::AutoscalingPollerBehavior, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/sdk/v1/workflow_metadata.rbi b/temporalio/rbi/temporalio/api/sdk/v1/workflow_metadata.rbi new file mode 100644 index 00000000..f1a67596 --- /dev/null +++ b/temporalio/rbi/temporalio/api/sdk/v1/workflow_metadata.rbi @@ -0,0 +1,297 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/sdk/v1/workflow_metadata.proto +# typed: strict + +# The name of the query to retrieve this information is `__temporal_workflow_metadata`. +class Temporalio::Api::Sdk::V1::WorkflowMetadata + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + definition: T.nilable(Temporalio::Api::Sdk::V1::WorkflowDefinition), + current_details: T.nilable(String) + ).void + end + def initialize( + definition: nil, + current_details: "" + ) + end + + # Metadata provided at declaration or creation time. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::WorkflowDefinition)) } + def definition + end + + # Metadata provided at declaration or creation time. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::WorkflowDefinition)).void } + def definition=(value) + end + + # Metadata provided at declaration or creation time. + sig { void } + def clear_definition + end + + # Current long-form details of the workflow's state. This is used by user interfaces to show +# long-form text. This text may be formatted by the user interface. + sig { returns(String) } + def current_details + end + + # Current long-form details of the workflow's state. This is used by user interfaces to show +# long-form text. This text may be formatted by the user interface. + sig { params(value: String).void } + def current_details=(value) + end + + # Current long-form details of the workflow's state. This is used by user interfaces to show +# long-form text. This text may be formatted by the user interface. + sig { void } + def clear_current_details + 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::Sdk::V1::WorkflowMetadata) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkflowMetadata).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::WorkflowMetadata) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkflowMetadata, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# (-- api-linter: core::0203::optional=disabled --) +class Temporalio::Api::Sdk::V1::WorkflowDefinition + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(String), + query_definitions: T.nilable(T::Array[T.nilable(Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition)]), + signal_definitions: T.nilable(T::Array[T.nilable(Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition)]), + update_definitions: T.nilable(T::Array[T.nilable(Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition)]) + ).void + end + def initialize( + type: "", + query_definitions: [], + signal_definitions: [], + update_definitions: [] + ) + end + + # A name scoped by the task queue that maps to this workflow definition. +# If missing, this workflow is a dynamic workflow. + sig { returns(String) } + def type + end + + # A name scoped by the task queue that maps to this workflow definition. +# If missing, this workflow is a dynamic workflow. + sig { params(value: String).void } + def type=(value) + end + + # A name scoped by the task queue that maps to this workflow definition. +# If missing, this workflow is a dynamic workflow. + sig { void } + def clear_type + end + + # Query definitions, sorted by name. + sig { returns(T::Array[T.nilable(Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition)]) } + def query_definitions + end + + # Query definitions, sorted by name. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def query_definitions=(value) + end + + # Query definitions, sorted by name. + sig { void } + def clear_query_definitions + end + + # Signal definitions, sorted by name. + sig { returns(T::Array[T.nilable(Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition)]) } + def signal_definitions + end + + # Signal definitions, sorted by name. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def signal_definitions=(value) + end + + # Signal definitions, sorted by name. + sig { void } + def clear_signal_definitions + end + + # Update definitions, sorted by name. + sig { returns(T::Array[T.nilable(Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition)]) } + def update_definitions + end + + # Update definitions, sorted by name. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def update_definitions=(value) + end + + # Update definitions, sorted by name. + sig { void } + def clear_update_definitions + 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::Sdk::V1::WorkflowDefinition) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkflowDefinition).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::WorkflowDefinition) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkflowDefinition, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# (-- api-linter: core::0123::resource-annotation=disabled +# aip.dev/not-precedent: The `name` field is optional. --) +# (-- api-linter: core::0203::optional=disabled --) +class Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + description: T.nilable(String) + ).void + end + def initialize( + name: "", + description: "" + ) + end + + # An optional name for the handler. If missing, it represents +# a dynamic handler that processes any interactions not handled by others. +# There is at most one dynamic handler per workflow and interaction kind. + sig { returns(String) } + def name + end + + # An optional name for the handler. If missing, it represents +# a dynamic handler that processes any interactions not handled by others. +# There is at most one dynamic handler per workflow and interaction kind. + sig { params(value: String).void } + def name=(value) + end + + # An optional name for the handler. If missing, it represents +# a dynamic handler that processes any interactions not handled by others. +# There is at most one dynamic handler per workflow and interaction kind. + sig { void } + def clear_name + end + + # An optional interaction description provided by the application. +# By convention, external tools may interpret its first part, +# i.e., ending with a line break, as a summary of the description. + sig { returns(String) } + def description + end + + # An optional interaction description provided by the application. +# By convention, external tools may interpret its first part, +# i.e., ending with a line break, as a summary of the description. + sig { params(value: String).void } + def description=(value) + end + + # An optional interaction description provided by the application. +# By convention, external tools may interpret its first part, +# i.e., ending with a line break, as a summary of the description. + sig { void } + def clear_description + 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::Sdk::V1::WorkflowInteractionDefinition) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Sdk::V1::WorkflowInteractionDefinition, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/taskqueue/v1/message.rbi b/temporalio/rbi/temporalio/api/taskqueue/v1/message.rbi new file mode 100644 index 00000000..886d6279 --- /dev/null +++ b/temporalio/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 diff --git a/temporalio/rbi/temporalio/api/testservice/v1/request_response.rbi b/temporalio/rbi/temporalio/api/testservice/v1/request_response.rbi new file mode 100644 index 00000000..2e169d97 --- /dev/null +++ b/temporalio/rbi/temporalio/api/testservice/v1/request_response.rbi @@ -0,0 +1,380 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/testservice/v1/request_response.proto +# typed: strict + +class Temporalio::Api::TestService::V1::LockTimeSkippingRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::TestService::V1::LockTimeSkippingRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::TestService::V1::LockTimeSkippingRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TestService::V1::LockTimeSkippingRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::TestService::V1::LockTimeSkippingRequest, 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::TestService::V1::LockTimeSkippingResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::TestService::V1::LockTimeSkippingResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::TestService::V1::LockTimeSkippingResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TestService::V1::LockTimeSkippingResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::TestService::V1::LockTimeSkippingResponse, 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::TestService::V1::UnlockTimeSkippingRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::TestService::V1::UnlockTimeSkippingRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::TestService::V1::UnlockTimeSkippingRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TestService::V1::UnlockTimeSkippingRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::TestService::V1::UnlockTimeSkippingRequest, 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::TestService::V1::UnlockTimeSkippingResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::TestService::V1::UnlockTimeSkippingResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::TestService::V1::UnlockTimeSkippingResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TestService::V1::UnlockTimeSkippingResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::TestService::V1::UnlockTimeSkippingResponse, 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::TestService::V1::SleepUntilRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + timestamp: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + timestamp: nil + ) + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def timestamp + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def timestamp=(value) + end + + sig { void } + def clear_timestamp + 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::TestService::V1::SleepUntilRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::TestService::V1::SleepUntilRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TestService::V1::SleepUntilRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::TestService::V1::SleepUntilRequest, 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::TestService::V1::SleepRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + duration: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + duration: nil + ) + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def duration + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def duration=(value) + end + + sig { void } + def clear_duration + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::TestService::V1::SleepRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::TestService::V1::SleepRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TestService::V1::SleepRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::TestService::V1::SleepRequest, 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::TestService::V1::SleepResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::TestService::V1::SleepResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::TestService::V1::SleepResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TestService::V1::SleepResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::TestService::V1::SleepResponse, 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::TestService::V1::GetCurrentTimeResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + time: nil + ) + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def time=(value) + end + + sig { void } + def clear_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::TestService::V1::GetCurrentTimeResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::TestService::V1::GetCurrentTimeResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::TestService::V1::GetCurrentTimeResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::TestService::V1::GetCurrentTimeResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/testservice/v1/service.rbi b/temporalio/rbi/temporalio/api/testservice/v1/service.rbi new file mode 100644 index 00000000..74a9eb6d --- /dev/null +++ b/temporalio/rbi/temporalio/api/testservice/v1/service.rbi @@ -0,0 +1,3 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/testservice/v1/service.proto +# typed: strict diff --git a/temporalio/rbi/temporalio/api/update/v1/message.rbi b/temporalio/rbi/temporalio/api/update/v1/message.rbi new file mode 100644 index 00000000..29b8aacc --- /dev/null +++ b/temporalio/rbi/temporalio/api/update/v1/message.rbi @@ -0,0 +1,749 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/update/v1/message.proto +# typed: strict + +# Specifies client's intent to wait for Update results. +class Temporalio::Api::Update::V1::WaitPolicy + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + lifecycle_stage: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + lifecycle_stage: :UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED + ) + end + + # Indicates the Update lifecycle stage that the Update must reach before +# API call is returned. +# NOTE: This field works together with API call timeout which is limited by +# server timeout (maximum wait time). If server timeout is expired before +# user specified timeout, API call returns even if specified stage is not reached. + sig { returns(T.any(Symbol, Integer)) } + def lifecycle_stage + end + + # Indicates the Update lifecycle stage that the Update must reach before +# API call is returned. +# NOTE: This field works together with API call timeout which is limited by +# server timeout (maximum wait time). If server timeout is expired before +# user specified timeout, API call returns even if specified stage is not reached. + sig { params(value: T.any(Symbol, String, Integer)).void } + def lifecycle_stage=(value) + end + + # Indicates the Update lifecycle stage that the Update must reach before +# API call is returned. +# NOTE: This field works together with API call timeout which is limited by +# server timeout (maximum wait time). If server timeout is expired before +# user specified timeout, API call returns even if specified stage is not reached. + sig { void } + def clear_lifecycle_stage + 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::Update::V1::WaitPolicy) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::WaitPolicy).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::WaitPolicy) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::WaitPolicy, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# The data needed by a client to refer to a previously invoked Workflow Update. +class Temporalio::Api::Update::V1::UpdateRef + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + update_id: T.nilable(String) + ).void + end + def initialize( + workflow_execution: nil, + update_id: "" + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(String) } + def update_id + end + + sig { params(value: String).void } + def update_id=(value) + end + + sig { void } + def clear_update_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::Update::V1::UpdateRef) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::UpdateRef).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::UpdateRef) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::UpdateRef, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# The outcome of a Workflow Update: success or failure. +class Temporalio::Api::Update::V1::Outcome + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + success: T.nilable(Temporalio::Api::Common::V1::Payloads), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + success: nil, + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def success + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def success=(value) + end + + sig { void } + def clear_success + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + end + + sig { returns(T.nilable(Symbol)) } + def value + 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::Update::V1::Outcome) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::Outcome).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::Outcome) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::Outcome, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Metadata about a Workflow Update. +class Temporalio::Api::Update::V1::Meta + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + update_id: T.nilable(String), + identity: T.nilable(String) + ).void + end + def initialize( + update_id: "", + identity: "" + ) + end + + # An ID with workflow-scoped uniqueness for this Update. + sig { returns(String) } + def update_id + end + + # An ID with workflow-scoped uniqueness for this Update. + sig { params(value: String).void } + def update_id=(value) + end + + # An ID with workflow-scoped uniqueness for this Update. + sig { void } + def clear_update_id + end + + # A string identifying the agent that requested this Update. + sig { returns(String) } + def identity + end + + # A string identifying the agent that requested this Update. + sig { params(value: String).void } + def identity=(value) + end + + # A string identifying the agent that requested this Update. + sig { void } + def clear_identity + 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::Update::V1::Meta) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::Meta).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::Meta) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::Meta, 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::Update::V1::Input + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + header: T.nilable(Temporalio::Api::Common::V1::Header), + name: T.nilable(String), + args: T.nilable(Temporalio::Api::Common::V1::Payloads) + ).void + end + def initialize( + header: nil, + name: "", + args: nil + ) + end + + # Headers that are passed with the Update from the requesting entity. +# These can include things like auth or tracing tokens. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Headers that are passed with the Update from the requesting entity. +# These can include things like auth or tracing tokens. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Headers that are passed with the Update from the requesting entity. +# These can include things like auth or tracing tokens. + sig { void } + def clear_header + end + + # The name of the Update handler to invoke on the target Workflow. + sig { returns(String) } + def name + end + + # The name of the Update handler to invoke on the target Workflow. + sig { params(value: String).void } + def name=(value) + end + + # The name of the Update handler to invoke on the target Workflow. + sig { void } + def clear_name + end + + # The arguments to pass to the named Update handler. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def args + end + + # The arguments to pass to the named Update handler. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def args=(value) + end + + # The arguments to pass to the named Update handler. + sig { void } + def clear_args + 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::Update::V1::Input) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::Input).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::Input) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::Input, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# The client request that triggers a Workflow Update. +class Temporalio::Api::Update::V1::Request + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + meta: T.nilable(Temporalio::Api::Update::V1::Meta), + input: T.nilable(Temporalio::Api::Update::V1::Input) + ).void + end + def initialize( + meta: nil, + input: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Update::V1::Meta)) } + def meta + end + + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Meta)).void } + def meta=(value) + end + + sig { void } + def clear_meta + end + + sig { returns(T.nilable(Temporalio::Api::Update::V1::Input)) } + def input + end + + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Input)).void } + def input=(value) + end + + sig { void } + def clear_input + 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::Update::V1::Request) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::Request).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::Request) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::Request, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# An Update protocol message indicating that a Workflow Update has been rejected. +class Temporalio::Api::Update::V1::Rejection + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rejected_request_message_id: T.nilable(String), + rejected_request_sequencing_event_id: T.nilable(Integer), + rejected_request: T.nilable(Temporalio::Api::Update::V1::Request), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + rejected_request_message_id: "", + rejected_request_sequencing_event_id: 0, + rejected_request: nil, + failure: nil + ) + end + + sig { returns(String) } + def rejected_request_message_id + end + + sig { params(value: String).void } + def rejected_request_message_id=(value) + end + + sig { void } + def clear_rejected_request_message_id + end + + sig { returns(Integer) } + def rejected_request_sequencing_event_id + end + + sig { params(value: Integer).void } + def rejected_request_sequencing_event_id=(value) + end + + sig { void } + def clear_rejected_request_sequencing_event_id + end + + sig { returns(T.nilable(Temporalio::Api::Update::V1::Request)) } + def rejected_request + end + + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Request)).void } + def rejected_request=(value) + end + + sig { void } + def clear_rejected_request + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Update::V1::Rejection) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::Rejection).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::Rejection) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::Rejection, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# An Update protocol message indicating that a Workflow Update has +# been accepted (i.e. passed the worker-side validation phase). +class Temporalio::Api::Update::V1::Acceptance + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + accepted_request_message_id: T.nilable(String), + accepted_request_sequencing_event_id: T.nilable(Integer), + accepted_request: T.nilable(Temporalio::Api::Update::V1::Request) + ).void + end + def initialize( + accepted_request_message_id: "", + accepted_request_sequencing_event_id: 0, + accepted_request: nil + ) + end + + sig { returns(String) } + def accepted_request_message_id + end + + sig { params(value: String).void } + def accepted_request_message_id=(value) + end + + sig { void } + def clear_accepted_request_message_id + end + + sig { returns(Integer) } + def accepted_request_sequencing_event_id + end + + sig { params(value: Integer).void } + def accepted_request_sequencing_event_id=(value) + end + + sig { void } + def clear_accepted_request_sequencing_event_id + end + + sig { returns(T.nilable(Temporalio::Api::Update::V1::Request)) } + def accepted_request + end + + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Request)).void } + def accepted_request=(value) + end + + sig { void } + def clear_accepted_request + 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::Update::V1::Acceptance) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::Acceptance).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::Acceptance) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::Acceptance, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# An Update protocol message indicating that a Workflow Update has +# completed with the contained outcome. +class Temporalio::Api::Update::V1::Response + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + meta: T.nilable(Temporalio::Api::Update::V1::Meta), + outcome: T.nilable(Temporalio::Api::Update::V1::Outcome) + ).void + end + def initialize( + meta: nil, + outcome: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Update::V1::Meta)) } + def meta + end + + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Meta)).void } + def meta=(value) + end + + sig { void } + def clear_meta + end + + sig { returns(T.nilable(Temporalio::Api::Update::V1::Outcome)) } + def outcome + end + + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Outcome)).void } + def outcome=(value) + end + + sig { void } + def clear_outcome + 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::Update::V1::Response) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Update::V1::Response).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Update::V1::Response) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Update::V1::Response, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/version/v1/message.rbi b/temporalio/rbi/temporalio/api/version/v1/message.rbi new file mode 100644 index 00000000..3a5a455d --- /dev/null +++ b/temporalio/rbi/temporalio/api/version/v1/message.rbi @@ -0,0 +1,281 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/version/v1/message.proto +# typed: strict + +# ReleaseInfo contains information about specific version of temporal. +class Temporalio::Api::Version::V1::ReleaseInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + version: T.nilable(String), + release_time: T.nilable(Google::Protobuf::Timestamp), + notes: T.nilable(String) + ).void + end + def initialize( + version: "", + release_time: nil, + notes: "" + ) + end + + sig { returns(String) } + def version + end + + sig { params(value: String).void } + def version=(value) + end + + sig { void } + def clear_version + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def release_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def release_time=(value) + end + + sig { void } + def clear_release_time + end + + sig { returns(String) } + def notes + end + + sig { params(value: String).void } + def notes=(value) + end + + sig { void } + def clear_notes + 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::Version::V1::ReleaseInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Version::V1::ReleaseInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Version::V1::ReleaseInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Version::V1::ReleaseInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Alert contains notification and severity. +class Temporalio::Api::Version::V1::Alert + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + message: T.nilable(String), + severity: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + message: "", + severity: :SEVERITY_UNSPECIFIED + ) + end + + sig { returns(String) } + def message + end + + sig { params(value: String).void } + def message=(value) + end + + sig { void } + def clear_message + end + + sig { returns(T.any(Symbol, Integer)) } + def severity + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def severity=(value) + end + + sig { void } + def clear_severity + 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::Version::V1::Alert) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Version::V1::Alert).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Version::V1::Alert) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Version::V1::Alert, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# VersionInfo contains details about current and recommended release versions as well as alerts and upgrade instructions. +class Temporalio::Api::Version::V1::VersionInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + current: T.nilable(Temporalio::Api::Version::V1::ReleaseInfo), + recommended: T.nilable(Temporalio::Api::Version::V1::ReleaseInfo), + instructions: T.nilable(String), + alerts: T.nilable(T::Array[T.nilable(Temporalio::Api::Version::V1::Alert)]), + last_update_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + current: nil, + recommended: nil, + instructions: "", + alerts: [], + last_update_time: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Version::V1::ReleaseInfo)) } + def current + end + + sig { params(value: T.nilable(Temporalio::Api::Version::V1::ReleaseInfo)).void } + def current=(value) + end + + sig { void } + def clear_current + end + + sig { returns(T.nilable(Temporalio::Api::Version::V1::ReleaseInfo)) } + def recommended + end + + sig { params(value: T.nilable(Temporalio::Api::Version::V1::ReleaseInfo)).void } + def recommended=(value) + end + + sig { void } + def clear_recommended + end + + sig { returns(String) } + def instructions + end + + sig { params(value: String).void } + def instructions=(value) + end + + sig { void } + def clear_instructions + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Version::V1::Alert)]) } + def alerts + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def alerts=(value) + end + + sig { void } + def clear_alerts + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_update_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_update_time=(value) + end + + sig { void } + def clear_last_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::Version::V1::VersionInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Version::V1::VersionInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Version::V1::VersionInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Version::V1::VersionInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/worker/v1/message.rbi b/temporalio/rbi/temporalio/api/worker/v1/message.rbi new file mode 100644 index 00000000..4fbdd97b --- /dev/null +++ b/temporalio/rbi/temporalio/api/worker/v1/message.rbi @@ -0,0 +1,1565 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/worker/v1/message.proto +# typed: strict + +class Temporalio::Api::Worker::V1::WorkerPollerInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + current_pollers: T.nilable(Integer), + last_successful_poll_time: T.nilable(Google::Protobuf::Timestamp), + is_autoscaling: T.nilable(T::Boolean) + ).void + end + def initialize( + current_pollers: 0, + last_successful_poll_time: nil, + is_autoscaling: false + ) + end + + # Number of polling RPCs that are currently in flight. + sig { returns(Integer) } + def current_pollers + end + + # Number of polling RPCs that are currently in flight. + sig { params(value: Integer).void } + def current_pollers=(value) + end + + # Number of polling RPCs that are currently in flight. + sig { void } + def clear_current_pollers + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_successful_poll_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_successful_poll_time=(value) + end + + sig { void } + def clear_last_successful_poll_time + end + + # Set true if the number of concurrent pollers is auto-scaled + sig { returns(T::Boolean) } + def is_autoscaling + end + + # Set true if the number of concurrent pollers is auto-scaled + sig { params(value: T::Boolean).void } + def is_autoscaling=(value) + end + + # Set true if the number of concurrent pollers is auto-scaled + sig { void } + def clear_is_autoscaling + 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::Worker::V1::WorkerPollerInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerPollerInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::WorkerPollerInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerPollerInfo, 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::Worker::V1::WorkerSlotsInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + current_available_slots: T.nilable(Integer), + current_used_slots: T.nilable(Integer), + slot_supplier_kind: T.nilable(String), + total_processed_tasks: T.nilable(Integer), + total_failed_tasks: T.nilable(Integer), + last_interval_processed_tasks: T.nilable(Integer), + last_interval_failure_tasks: T.nilable(Integer) + ).void + end + def initialize( + current_available_slots: 0, + current_used_slots: 0, + slot_supplier_kind: "", + total_processed_tasks: 0, + total_failed_tasks: 0, + last_interval_processed_tasks: 0, + last_interval_failure_tasks: 0 + ) + end + + # Number of slots available for the worker to specific tasks. +# May be -1 if the upper bound is not known. + sig { returns(Integer) } + def current_available_slots + end + + # Number of slots available for the worker to specific tasks. +# May be -1 if the upper bound is not known. + sig { params(value: Integer).void } + def current_available_slots=(value) + end + + # Number of slots available for the worker to specific tasks. +# May be -1 if the upper bound is not known. + sig { void } + def clear_current_available_slots + end + + # Number of slots used by the worker for specific tasks. + sig { returns(Integer) } + def current_used_slots + end + + # Number of slots used by the worker for specific tasks. + sig { params(value: Integer).void } + def current_used_slots=(value) + end + + # Number of slots used by the worker for specific tasks. + sig { void } + def clear_current_used_slots + end + + # Kind of the slot supplier, which is used to determine how the slots are allocated. +# Possible values: "Fixed | ResourceBased | Custom String" + sig { returns(String) } + def slot_supplier_kind + end + + # Kind of the slot supplier, which is used to determine how the slots are allocated. +# Possible values: "Fixed | ResourceBased | Custom String" + sig { params(value: String).void } + def slot_supplier_kind=(value) + end + + # Kind of the slot supplier, which is used to determine how the slots are allocated. +# Possible values: "Fixed | ResourceBased | Custom String" + sig { void } + def clear_slot_supplier_kind + end + + # Total number of tasks processed (completed both successfully and unsuccesfully, or any other way) +# by the worker since the worker started. This is a cumulative counter. + sig { returns(Integer) } + def total_processed_tasks + end + + # Total number of tasks processed (completed both successfully and unsuccesfully, or any other way) +# by the worker since the worker started. This is a cumulative counter. + sig { params(value: Integer).void } + def total_processed_tasks=(value) + end + + # Total number of tasks processed (completed both successfully and unsuccesfully, or any other way) +# by the worker since the worker started. This is a cumulative counter. + sig { void } + def clear_total_processed_tasks + end + + # Total number of failed tasks processed by the worker so far. + sig { returns(Integer) } + def total_failed_tasks + end + + # Total number of failed tasks processed by the worker so far. + sig { params(value: Integer).void } + def total_failed_tasks=(value) + end + + # Total number of failed tasks processed by the worker so far. + sig { void } + def clear_total_failed_tasks + end + + # Number of tasks processed in since the last heartbeat from the worker. +# This is a cumulative counter, and it is reset to 0 each time the worker sends a heartbeat. +# Contains both successful and failed tasks. + sig { returns(Integer) } + def last_interval_processed_tasks + end + + # Number of tasks processed in since the last heartbeat from the worker. +# This is a cumulative counter, and it is reset to 0 each time the worker sends a heartbeat. +# Contains both successful and failed tasks. + sig { params(value: Integer).void } + def last_interval_processed_tasks=(value) + end + + # Number of tasks processed in since the last heartbeat from the worker. +# This is a cumulative counter, and it is reset to 0 each time the worker sends a heartbeat. +# Contains both successful and failed tasks. + sig { void } + def clear_last_interval_processed_tasks + end + + # Number of failed tasks processed since the last heartbeat from the worker. + sig { returns(Integer) } + def last_interval_failure_tasks + end + + # Number of failed tasks processed since the last heartbeat from the worker. + sig { params(value: Integer).void } + def last_interval_failure_tasks=(value) + end + + # Number of failed tasks processed since the last heartbeat from the worker. + sig { void } + def clear_last_interval_failure_tasks + 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::Worker::V1::WorkerSlotsInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerSlotsInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::WorkerSlotsInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerSlotsInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Holds everything needed to identify the worker host/process context +class Temporalio::Api::Worker::V1::WorkerHostInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + host_name: T.nilable(String), + worker_grouping_key: T.nilable(String), + process_id: T.nilable(String), + current_host_cpu_usage: T.nilable(Float), + current_host_mem_usage: T.nilable(Float) + ).void + end + def initialize( + host_name: "", + worker_grouping_key: "", + process_id: "", + current_host_cpu_usage: 0.0, + current_host_mem_usage: 0.0 + ) + end + + # Worker host identifier. + sig { returns(String) } + def host_name + end + + # Worker host identifier. + sig { params(value: String).void } + def host_name=(value) + end + + # Worker host identifier. + sig { void } + def clear_host_name + end + + # Worker grouping identifier. A key to group workers that share the same client+namespace+process. +# This will be used to build the worker command nexus task queue name: +# "temporal-sys/worker-commands/{worker_grouping_key}" + sig { returns(String) } + def worker_grouping_key + end + + # Worker grouping identifier. A key to group workers that share the same client+namespace+process. +# This will be used to build the worker command nexus task queue name: +# "temporal-sys/worker-commands/{worker_grouping_key}" + sig { params(value: String).void } + def worker_grouping_key=(value) + end + + # Worker grouping identifier. A key to group workers that share the same client+namespace+process. +# This will be used to build the worker command nexus task queue name: +# "temporal-sys/worker-commands/{worker_grouping_key}" + sig { void } + def clear_worker_grouping_key + end + + # Worker process identifier. This id only needs to be unique +# within one host (so using e.g. a unix pid would be appropriate). + sig { returns(String) } + def process_id + end + + # Worker process identifier. This id only needs to be unique +# within one host (so using e.g. a unix pid would be appropriate). + sig { params(value: String).void } + def process_id=(value) + end + + # Worker process identifier. This id only needs to be unique +# within one host (so using e.g. a unix pid would be appropriate). + sig { void } + def clear_process_id + end + + # System used CPU as a float in the range [0.0, 1.0] where 1.0 is defined as all +# cores on the host pegged. + sig { returns(Float) } + def current_host_cpu_usage + end + + # System used CPU as a float in the range [0.0, 1.0] where 1.0 is defined as all +# cores on the host pegged. + sig { params(value: Float).void } + def current_host_cpu_usage=(value) + end + + # System used CPU as a float in the range [0.0, 1.0] where 1.0 is defined as all +# cores on the host pegged. + sig { void } + def clear_current_host_cpu_usage + end + + # System used memory as a float in the range [0.0, 1.0] where 1.0 is defined as +# all available memory on the host is used. + sig { returns(Float) } + def current_host_mem_usage + end + + # System used memory as a float in the range [0.0, 1.0] where 1.0 is defined as +# all available memory on the host is used. + sig { params(value: Float).void } + def current_host_mem_usage=(value) + end + + # System used memory as a float in the range [0.0, 1.0] where 1.0 is defined as +# all available memory on the host is used. + sig { void } + def clear_current_host_mem_usage + 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::Worker::V1::WorkerHostInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerHostInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::WorkerHostInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerHostInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Worker info message, contains information about the worker and its current state. +# All information is provided by the worker itself. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: Removing those words make names less clear. --) +class Temporalio::Api::Worker::V1::WorkerHeartbeat + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_instance_key: T.nilable(String), + worker_identity: T.nilable(String), + host_info: T.nilable(Temporalio::Api::Worker::V1::WorkerHostInfo), + task_queue: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + sdk_name: T.nilable(String), + sdk_version: T.nilable(String), + status: T.nilable(T.any(Symbol, String, Integer)), + start_time: T.nilable(Google::Protobuf::Timestamp), + heartbeat_time: T.nilable(Google::Protobuf::Timestamp), + elapsed_since_last_heartbeat: T.nilable(Google::Protobuf::Duration), + workflow_task_slots_info: T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo), + activity_task_slots_info: T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo), + nexus_task_slots_info: T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo), + local_activity_slots_info: T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo), + workflow_poller_info: T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo), + workflow_sticky_poller_info: T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo), + activity_poller_info: T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo), + nexus_poller_info: T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo), + total_sticky_cache_hit: T.nilable(Integer), + total_sticky_cache_miss: T.nilable(Integer), + current_sticky_cache_size: T.nilable(Integer), + plugins: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::PluginInfo)]), + drivers: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::StorageDriverInfo)]) + ).void + end + def initialize( + worker_instance_key: "", + worker_identity: "", + host_info: nil, + task_queue: "", + deployment_version: nil, + sdk_name: "", + sdk_version: "", + status: :WORKER_STATUS_UNSPECIFIED, + start_time: nil, + heartbeat_time: nil, + elapsed_since_last_heartbeat: nil, + workflow_task_slots_info: nil, + activity_task_slots_info: nil, + nexus_task_slots_info: nil, + local_activity_slots_info: nil, + workflow_poller_info: nil, + workflow_sticky_poller_info: nil, + activity_poller_info: nil, + nexus_poller_info: nil, + total_sticky_cache_hit: 0, + total_sticky_cache_miss: 0, + current_sticky_cache_size: 0, + plugins: [], + drivers: [] + ) + end + + # Worker identifier, should be unique for the namespace. +# It is distinct from worker identity, which is not necessarily namespace-unique. + sig { returns(String) } + def worker_instance_key + end + + # Worker identifier, should be unique for the namespace. +# It is distinct from worker identity, which is not necessarily namespace-unique. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # Worker identifier, should be unique for the namespace. +# It is distinct from worker identity, which is not necessarily namespace-unique. + sig { void } + def clear_worker_instance_key + end + + # Worker identity, set by the client, may not be unique. +# Usually host_name+(user group name)+process_id, but can be overwritten by the user. + sig { returns(String) } + def worker_identity + end + + # Worker identity, set by the client, may not be unique. +# Usually host_name+(user group name)+process_id, but can be overwritten by the user. + sig { params(value: String).void } + def worker_identity=(value) + end + + # Worker identity, set by the client, may not be unique. +# Usually host_name+(user group name)+process_id, but can be overwritten by the user. + sig { void } + def clear_worker_identity + end + + # Worker host information. + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerHostInfo)) } + def host_info + end + + # Worker host information. + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerHostInfo)).void } + def host_info=(value) + end + + # Worker host information. + sig { void } + def clear_host_info + end + + # Task queue this worker is polling for tasks. + sig { returns(String) } + def task_queue + end + + # Task queue this worker is polling for tasks. + sig { params(value: String).void } + def task_queue=(value) + end + + # Task queue this worker is polling for tasks. + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + sig { void } + def clear_deployment_version + end + + sig { returns(String) } + def sdk_name + end + + sig { params(value: String).void } + def sdk_name=(value) + end + + sig { void } + def clear_sdk_name + end + + sig { returns(String) } + def sdk_version + end + + sig { params(value: String).void } + def sdk_version=(value) + end + + sig { void } + def clear_sdk_version + end + + # Worker status. Defined by SDK. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # Worker status. Defined by SDK. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # Worker status. Defined by SDK. + sig { void } + def clear_status + end + + # Worker start time. +# It can be used to determine worker uptime. (current time - start time) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # Worker start time. +# It can be used to determine worker uptime. (current time - start time) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # Worker start time. +# It can be used to determine worker uptime. (current time - start time) + sig { void } + def clear_start_time + end + + # Timestamp of this heartbeat, coming from the worker. Worker should set it to "now". +# Note that this timestamp comes directly from the worker and is subject to workers' clock skew. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def heartbeat_time + end + + # Timestamp of this heartbeat, coming from the worker. Worker should set it to "now". +# Note that this timestamp comes directly from the worker and is subject to workers' clock skew. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def heartbeat_time=(value) + end + + # Timestamp of this heartbeat, coming from the worker. Worker should set it to "now". +# Note that this timestamp comes directly from the worker and is subject to workers' clock skew. + sig { void } + def clear_heartbeat_time + end + + # Elapsed time since the last heartbeat from the worker. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def elapsed_since_last_heartbeat + end + + # Elapsed time since the last heartbeat from the worker. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def elapsed_since_last_heartbeat=(value) + end + + # Elapsed time since the last heartbeat from the worker. + sig { void } + def clear_elapsed_since_last_heartbeat + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo)) } + def workflow_task_slots_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo)).void } + def workflow_task_slots_info=(value) + end + + sig { void } + def clear_workflow_task_slots_info + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo)) } + def activity_task_slots_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo)).void } + def activity_task_slots_info=(value) + end + + sig { void } + def clear_activity_task_slots_info + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo)) } + def nexus_task_slots_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo)).void } + def nexus_task_slots_info=(value) + end + + sig { void } + def clear_nexus_task_slots_info + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo)) } + def local_activity_slots_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerSlotsInfo)).void } + def local_activity_slots_info=(value) + end + + sig { void } + def clear_local_activity_slots_info + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo)) } + def workflow_poller_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo)).void } + def workflow_poller_info=(value) + end + + sig { void } + def clear_workflow_poller_info + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo)) } + def workflow_sticky_poller_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo)).void } + def workflow_sticky_poller_info=(value) + end + + sig { void } + def clear_workflow_sticky_poller_info + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo)) } + def activity_poller_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo)).void } + def activity_poller_info=(value) + end + + sig { void } + def clear_activity_poller_info + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo)) } + def nexus_poller_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerPollerInfo)).void } + def nexus_poller_info=(value) + end + + sig { void } + def clear_nexus_poller_info + end + + # A Workflow Task found a cached Workflow Execution to run against. + sig { returns(Integer) } + def total_sticky_cache_hit + end + + # A Workflow Task found a cached Workflow Execution to run against. + sig { params(value: Integer).void } + def total_sticky_cache_hit=(value) + end + + # A Workflow Task found a cached Workflow Execution to run against. + sig { void } + def clear_total_sticky_cache_hit + end + + # A Workflow Task did not find a cached Workflow execution to run against. + sig { returns(Integer) } + def total_sticky_cache_miss + end + + # A Workflow Task did not find a cached Workflow execution to run against. + sig { params(value: Integer).void } + def total_sticky_cache_miss=(value) + end + + # A Workflow Task did not find a cached Workflow execution to run against. + sig { void } + def clear_total_sticky_cache_miss + end + + # Current cache size, expressed in number of Workflow Executions. + sig { returns(Integer) } + def current_sticky_cache_size + end + + # Current cache size, expressed in number of Workflow Executions. + sig { params(value: Integer).void } + def current_sticky_cache_size=(value) + end + + # Current cache size, expressed in number of Workflow Executions. + sig { void } + def clear_current_sticky_cache_size + end + + # Plugins currently in use by this SDK. + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::PluginInfo)]) } + def plugins + end + + # Plugins currently in use by this SDK. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def plugins=(value) + end + + # Plugins currently in use by this SDK. + sig { void } + def clear_plugins + end + + # Storage drivers in use by this SDK. + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::StorageDriverInfo)]) } + def drivers + end + + # Storage drivers in use by this SDK. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def drivers=(value) + end + + # Storage drivers in use by this SDK. + sig { void } + def clear_drivers + 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::Worker::V1::WorkerHeartbeat) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerHeartbeat).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::WorkerHeartbeat) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerHeartbeat, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Detailed worker information. +class Temporalio::Api::Worker::V1::WorkerInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_heartbeat: T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat) + ).void + end + def initialize( + worker_heartbeat: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat)) } + def worker_heartbeat + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat)).void } + def worker_heartbeat=(value) + end + + sig { void } + def clear_worker_heartbeat + 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::Worker::V1::WorkerInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::WorkerInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Limited worker information returned in the list response. +# When adding fields here, ensure that it is also added to WorkerInfo (as it carries the full worker information). +class Temporalio::Api::Worker::V1::WorkerListInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_instance_key: T.nilable(String), + worker_identity: T.nilable(String), + task_queue: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + sdk_name: T.nilable(String), + sdk_version: T.nilable(String), + status: T.nilable(T.any(Symbol, String, Integer)), + start_time: T.nilable(Google::Protobuf::Timestamp), + host_name: T.nilable(String), + worker_grouping_key: T.nilable(String), + process_id: T.nilable(String), + plugins: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::PluginInfo)]), + drivers: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::StorageDriverInfo)]) + ).void + end + def initialize( + worker_instance_key: "", + worker_identity: "", + task_queue: "", + deployment_version: nil, + sdk_name: "", + sdk_version: "", + status: :WORKER_STATUS_UNSPECIFIED, + start_time: nil, + host_name: "", + worker_grouping_key: "", + process_id: "", + plugins: [], + drivers: [] + ) + end + + # Worker identifier, should be unique for the namespace. +# It is distinct from worker identity, which is not necessarily namespace-unique. + sig { returns(String) } + def worker_instance_key + end + + # Worker identifier, should be unique for the namespace. +# It is distinct from worker identity, which is not necessarily namespace-unique. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # Worker identifier, should be unique for the namespace. +# It is distinct from worker identity, which is not necessarily namespace-unique. + sig { void } + def clear_worker_instance_key + end + + # Worker identity, set by the client, may not be unique. +# Usually host_name+(user group name)+process_id, but can be overwritten by the user. + sig { returns(String) } + def worker_identity + end + + # Worker identity, set by the client, may not be unique. +# Usually host_name+(user group name)+process_id, but can be overwritten by the user. + sig { params(value: String).void } + def worker_identity=(value) + end + + # Worker identity, set by the client, may not be unique. +# Usually host_name+(user group name)+process_id, but can be overwritten by the user. + sig { void } + def clear_worker_identity + end + + # Task queue this worker is polling for tasks. + sig { returns(String) } + def task_queue + end + + # Task queue this worker is polling for tasks. + sig { params(value: String).void } + def task_queue=(value) + end + + # Task queue this worker is polling for tasks. + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + sig { void } + def clear_deployment_version + end + + sig { returns(String) } + def sdk_name + end + + sig { params(value: String).void } + def sdk_name=(value) + end + + sig { void } + def clear_sdk_name + end + + sig { returns(String) } + def sdk_version + end + + sig { params(value: String).void } + def sdk_version=(value) + end + + sig { void } + def clear_sdk_version + end + + # Worker status. Defined by SDK. + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # Worker status. Defined by SDK. + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # Worker status. Defined by SDK. + sig { void } + def clear_status + end + + # Worker start time. +# It can be used to determine worker uptime. (current time - start time) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # Worker start time. +# It can be used to determine worker uptime. (current time - start time) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # Worker start time. +# It can be used to determine worker uptime. (current time - start time) + sig { void } + def clear_start_time + end + + # Worker host identifier. + sig { returns(String) } + def host_name + end + + # Worker host identifier. + sig { params(value: String).void } + def host_name=(value) + end + + # Worker host identifier. + sig { void } + def clear_host_name + end + + # Worker grouping identifier. A key to group workers that share the same client+namespace+process. +# This will be used to build the worker command nexus task queue name: +# "temporal-sys/worker-commands/{worker_grouping_key}" + sig { returns(String) } + def worker_grouping_key + end + + # Worker grouping identifier. A key to group workers that share the same client+namespace+process. +# This will be used to build the worker command nexus task queue name: +# "temporal-sys/worker-commands/{worker_grouping_key}" + sig { params(value: String).void } + def worker_grouping_key=(value) + end + + # Worker grouping identifier. A key to group workers that share the same client+namespace+process. +# This will be used to build the worker command nexus task queue name: +# "temporal-sys/worker-commands/{worker_grouping_key}" + sig { void } + def clear_worker_grouping_key + end + + # Worker process identifier. This id only needs to be unique +# within one host (so using e.g. a unix pid would be appropriate). + sig { returns(String) } + def process_id + end + + # Worker process identifier. This id only needs to be unique +# within one host (so using e.g. a unix pid would be appropriate). + sig { params(value: String).void } + def process_id=(value) + end + + # Worker process identifier. This id only needs to be unique +# within one host (so using e.g. a unix pid would be appropriate). + sig { void } + def clear_process_id + end + + # Plugins currently in use by this SDK. + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::PluginInfo)]) } + def plugins + end + + # Plugins currently in use by this SDK. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def plugins=(value) + end + + # Plugins currently in use by this SDK. + sig { void } + def clear_plugins + end + + # Storage drivers in use by this SDK. + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::StorageDriverInfo)]) } + def drivers + end + + # Storage drivers in use by this SDK. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def drivers=(value) + end + + # Storage drivers in use by this SDK. + sig { void } + def clear_drivers + 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::Worker::V1::WorkerListInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerListInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::WorkerListInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerListInfo, 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::Worker::V1::PluginInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + version: T.nilable(String) + ).void + end + def initialize( + name: "", + version: "" + ) + end + + # The name of the plugin, required. + sig { returns(String) } + def name + end + + # The name of the plugin, required. + sig { params(value: String).void } + def name=(value) + end + + # The name of the plugin, required. + sig { void } + def clear_name + end + + # The version of the plugin, may be empty. + sig { returns(String) } + def version + end + + # The version of the plugin, may be empty. + sig { params(value: String).void } + def version=(value) + end + + # The version of the plugin, may be empty. + sig { void } + def clear_version + 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::Worker::V1::PluginInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::PluginInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::PluginInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::PluginInfo, 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::Worker::V1::StorageDriverInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + type: T.nilable(String) + ).void + end + def initialize( + type: "" + ) + end + + # The type of the driver, required. + sig { returns(String) } + def type + end + + # The type of the driver, required. + sig { params(value: String).void } + def type=(value) + end + + # The type of the driver, required. + sig { void } + def clear_type + 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::Worker::V1::StorageDriverInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::StorageDriverInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::StorageDriverInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::StorageDriverInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A command sent from the server to a worker. +class Temporalio::Api::Worker::V1::WorkerCommand + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cancel_activity: T.nilable(Temporalio::Api::Worker::V1::CancelActivityCommand) + ).void + end + def initialize( + cancel_activity: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::CancelActivityCommand)) } + def cancel_activity + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::CancelActivityCommand)).void } + def cancel_activity=(value) + end + + sig { void } + def clear_cancel_activity + end + + sig { returns(T.nilable(Symbol)) } + def type + 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::Worker::V1::WorkerCommand) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerCommand).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::WorkerCommand) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerCommand, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Cancel an activity if it is still running. Otherwise, do nothing. +class Temporalio::Api::Worker::V1::CancelActivityCommand + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String) + ).void + end + def initialize( + task_token: "" + ) + end + + sig { returns(String) } + def task_token + end + + sig { params(value: String).void } + def task_token=(value) + end + + sig { void } + def clear_task_token + 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::Worker::V1::CancelActivityCommand) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::CancelActivityCommand).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::CancelActivityCommand) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::CancelActivityCommand, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# The result of executing a WorkerCommand. +class Temporalio::Api::Worker::V1::WorkerCommandResult + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cancel_activity: T.nilable(Temporalio::Api::Worker::V1::CancelActivityResult) + ).void + end + def initialize( + cancel_activity: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::CancelActivityResult)) } + def cancel_activity + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::CancelActivityResult)).void } + def cancel_activity=(value) + end + + sig { void } + def clear_cancel_activity + end + + sig { returns(T.nilable(Symbol)) } + def type + 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::Worker::V1::WorkerCommandResult) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerCommandResult).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::WorkerCommandResult) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::WorkerCommandResult, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Result of a CancelActivityCommand. +# Treat both successful cancellation and no-op (activity is no longer running) as success. +class Temporalio::Api::Worker::V1::CancelActivityResult + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Worker::V1::CancelActivityResult) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Worker::V1::CancelActivityResult).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Worker::V1::CancelActivityResult) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Worker::V1::CancelActivityResult, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/workflow/v1/message.rbi b/temporalio/rbi/temporalio/api/workflow/v1/message.rbi new file mode 100644 index 00000000..382ca5a7 --- /dev/null +++ b/temporalio/rbi/temporalio/api/workflow/v1/message.rbi @@ -0,0 +1,4923 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/workflow/v1/message.proto +# typed: strict + +# Hold basic information about a workflow execution. +# This structure is a part of visibility, and thus contain a limited subset of information. +class Temporalio::Api::Workflow::V1::WorkflowExecutionInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + start_time: T.nilable(Google::Protobuf::Timestamp), + close_time: T.nilable(Google::Protobuf::Timestamp), + status: T.nilable(T.any(Symbol, String, Integer)), + history_length: T.nilable(Integer), + parent_namespace_id: T.nilable(String), + parent_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + execution_time: T.nilable(Google::Protobuf::Timestamp), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + auto_reset_points: T.nilable(Temporalio::Api::Workflow::V1::ResetPoints), + task_queue: T.nilable(String), + state_transition_count: T.nilable(Integer), + history_size_bytes: T.nilable(Integer), + most_recent_worker_version_stamp: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + execution_duration: T.nilable(Google::Protobuf::Duration), + root_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + assigned_build_id: T.nilable(String), + inherited_build_id: T.nilable(String), + first_run_id: T.nilable(String), + versioning_info: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionVersioningInfo), + worker_deployment_name: T.nilable(String), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + external_payload_size_bytes: T.nilable(Integer), + external_payload_count: T.nilable(Integer) + ).void + end + def initialize( + execution: nil, + type: nil, + start_time: nil, + close_time: nil, + status: :WORKFLOW_EXECUTION_STATUS_UNSPECIFIED, + history_length: 0, + parent_namespace_id: "", + parent_execution: nil, + execution_time: nil, + memo: nil, + search_attributes: nil, + auto_reset_points: nil, + task_queue: "", + state_transition_count: 0, + history_size_bytes: 0, + most_recent_worker_version_stamp: nil, + execution_duration: nil, + root_execution: nil, + assigned_build_id: "", + inherited_build_id: "", + first_run_id: "", + versioning_info: nil, + worker_deployment_name: "", + priority: nil, + external_payload_size_bytes: 0, + external_payload_count: 0 + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + sig { void } + def clear_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def type=(value) + end + + sig { void } + def clear_type + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + sig { void } + def clear_start_time + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def close_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def close_time=(value) + end + + sig { void } + def clear_close_time + end + + sig { returns(T.any(Symbol, Integer)) } + def status + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + sig { void } + def clear_status + end + + sig { returns(Integer) } + def history_length + end + + sig { params(value: Integer).void } + def history_length=(value) + end + + sig { void } + def clear_history_length + end + + sig { returns(String) } + def parent_namespace_id + end + + sig { params(value: String).void } + def parent_namespace_id=(value) + end + + sig { void } + def clear_parent_namespace_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def parent_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def parent_execution=(value) + end + + sig { void } + def clear_parent_execution + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def execution_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def execution_time=(value) + end + + sig { void } + def clear_execution_time + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::ResetPoints)) } + def auto_reset_points + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::ResetPoints)).void } + def auto_reset_points=(value) + end + + sig { void } + def clear_auto_reset_points + 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 + + sig { returns(Integer) } + def state_transition_count + end + + sig { params(value: Integer).void } + def state_transition_count=(value) + end + + sig { void } + def clear_state_transition_count + end + + sig { returns(Integer) } + def history_size_bytes + end + + sig { params(value: Integer).void } + def history_size_bytes=(value) + end + + sig { void } + def clear_history_size_bytes + end + + # If set, the most recent worker version stamp that appeared in a workflow task completion +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def most_recent_worker_version_stamp + end + + # If set, the most recent worker version stamp that appeared in a workflow task completion +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def most_recent_worker_version_stamp=(value) + end + + # If set, the most recent worker version stamp that appeared in a workflow task completion +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_most_recent_worker_version_stamp + end + + # Workflow execution duration is defined as difference between close time and execution time. +# This field is only populated if the workflow is closed. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def execution_duration + end + + # Workflow execution duration is defined as difference between close time and execution time. +# This field is only populated if the workflow is closed. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def execution_duration=(value) + end + + # Workflow execution duration is defined as difference between close time and execution time. +# This field is only populated if the workflow is closed. + sig { void } + def clear_execution_duration + end + + # Contains information about the root workflow execution. +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# Note: workflows continued as new or reseted may or may not have parents, check examples below. +# +# Examples: +# Scenario 1: Workflow W1 starts child workflow W2, and W2 starts child workflow W3. +# - The root workflow of all three workflows is W1. +# Scenario 2: Workflow W1 starts child workflow W2, and W2 continued as new W3. +# - The root workflow of all three workflows is W1. +# Scenario 3: Workflow W1 continued as new W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# Scenario 4: Workflow W1 starts child workflow W2, and W2 is reseted, creating W3 +# - The root workflow of all three workflows is W1. +# Scenario 5: Workflow W1 is reseted, creating W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def root_execution + end + + # Contains information about the root workflow execution. +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# Note: workflows continued as new or reseted may or may not have parents, check examples below. +# +# Examples: +# Scenario 1: Workflow W1 starts child workflow W2, and W2 starts child workflow W3. +# - The root workflow of all three workflows is W1. +# Scenario 2: Workflow W1 starts child workflow W2, and W2 continued as new W3. +# - The root workflow of all three workflows is W1. +# Scenario 3: Workflow W1 continued as new W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# Scenario 4: Workflow W1 starts child workflow W2, and W2 is reseted, creating W3 +# - The root workflow of all three workflows is W1. +# Scenario 5: Workflow W1 is reseted, creating W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def root_execution=(value) + end + + # Contains information about the root workflow execution. +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# Note: workflows continued as new or reseted may or may not have parents, check examples below. +# +# Examples: +# Scenario 1: Workflow W1 starts child workflow W2, and W2 starts child workflow W3. +# - The root workflow of all three workflows is W1. +# Scenario 2: Workflow W1 starts child workflow W2, and W2 continued as new W3. +# - The root workflow of all three workflows is W1. +# Scenario 3: Workflow W1 continued as new W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. +# Scenario 4: Workflow W1 starts child workflow W2, and W2 is reseted, creating W3 +# - The root workflow of all three workflows is W1. +# Scenario 5: Workflow W1 is reseted, creating W2. +# - The root workflow of W1 is W1 and the root workflow of W2 is W2. + sig { void } + def clear_root_execution + end + + # The currently assigned build ID for this execution. Presence of this value means worker versioning is used +# for this execution. Assigned build ID is selected based on Worker Versioning Assignment Rules +# when the first workflow task of the execution is scheduled. If the first workflow task fails and is scheduled +# again, the assigned build ID may change according to the latest versioning rules. +# Assigned build ID can also change in the middle of a execution if Compatible Redirect Rules are applied to +# this execution. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(String) } + def assigned_build_id + end + + # The currently assigned build ID for this execution. Presence of this value means worker versioning is used +# for this execution. Assigned build ID is selected based on Worker Versioning Assignment Rules +# when the first workflow task of the execution is scheduled. If the first workflow task fails and is scheduled +# again, the assigned build ID may change according to the latest versioning rules. +# Assigned build ID can also change in the middle of a execution if Compatible Redirect Rules are applied to +# this execution. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: String).void } + def assigned_build_id=(value) + end + + # The currently assigned build ID for this execution. Presence of this value means worker versioning is used +# for this execution. Assigned build ID is selected based on Worker Versioning Assignment Rules +# when the first workflow task of the execution is scheduled. If the first workflow task fails and is scheduled +# again, the assigned build ID may change according to the latest versioning rules. +# Assigned build ID can also change in the middle of a execution if Compatible Redirect Rules are applied to +# this execution. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_assigned_build_id + end + + # Build ID inherited from a previous/parent execution. If present, assigned_build_id will be set to this, instead +# of using the assignment rules. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(String) } + def inherited_build_id + end + + # Build ID inherited from a previous/parent execution. If present, assigned_build_id will be set to this, instead +# of using the assignment rules. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: String).void } + def inherited_build_id=(value) + end + + # Build ID inherited from a previous/parent execution. If present, assigned_build_id will be set to this, instead +# of using the assignment rules. +# Deprecated. This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_inherited_build_id + end + + # The first run ID in the execution chain. +# Executions created via the following operations are considered to be in the same chain +# - ContinueAsNew +# - Workflow Retry +# - Workflow Reset +# - Cron Schedule + sig { returns(String) } + def first_run_id + end + + # The first run ID in the execution chain. +# Executions created via the following operations are considered to be in the same chain +# - ContinueAsNew +# - Workflow Retry +# - Workflow Reset +# - Cron Schedule + sig { params(value: String).void } + def first_run_id=(value) + end + + # The first run ID in the execution chain. +# Executions created via the following operations are considered to be in the same chain +# - ContinueAsNew +# - Workflow Retry +# - Workflow Reset +# - Cron Schedule + sig { void } + def clear_first_run_id + end + + # Absent value means the workflow execution is not versioned. When present, the execution might +# be versioned or unversioned, depending on `versioning_info.behavior` and `versioning_info.versioning_override`. +# Experimental. Versioning info is experimental and might change in the future. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionVersioningInfo)) } + def versioning_info + end + + # Absent value means the workflow execution is not versioned. When present, the execution might +# be versioned or unversioned, depending on `versioning_info.behavior` and `versioning_info.versioning_override`. +# Experimental. Versioning info is experimental and might change in the future. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionVersioningInfo)).void } + def versioning_info=(value) + end + + # Absent value means the workflow execution is not versioned. When present, the execution might +# be versioned or unversioned, depending on `versioning_info.behavior` and `versioning_info.versioning_override`. +# Experimental. Versioning info is experimental and might change in the future. + sig { void } + def clear_versioning_info + end + + # The name of Worker Deployment that completed the most recent workflow task. + sig { returns(String) } + def worker_deployment_name + end + + # The name of Worker Deployment that completed the most recent workflow task. + sig { params(value: String).void } + def worker_deployment_name=(value) + end + + # The name of Worker Deployment that completed the most recent workflow task. + sig { void } + def clear_worker_deployment_name + end + + # Priority metadata + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata + sig { void } + def clear_priority + end + + # Total size in bytes of all external payloads referenced in workflow history. + sig { returns(Integer) } + def external_payload_size_bytes + end + + # Total size in bytes of all external payloads referenced in workflow history. + sig { params(value: Integer).void } + def external_payload_size_bytes=(value) + end + + # Total size in bytes of all external payloads referenced in workflow history. + sig { void } + def clear_external_payload_size_bytes + end + + # Count of external payloads referenced in workflow history. + sig { returns(Integer) } + def external_payload_count + end + + # Count of external payloads referenced in workflow history. + sig { params(value: Integer).void } + def external_payload_count=(value) + end + + # Count of external payloads referenced in workflow history. + sig { void } + def clear_external_payload_count + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Holds all the extra information about workflow execution that is not part of Visibility. +class Temporalio::Api::Workflow::V1::WorkflowExecutionExtendedInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + execution_expiration_time: T.nilable(Google::Protobuf::Timestamp), + run_expiration_time: T.nilable(Google::Protobuf::Timestamp), + cancel_requested: T.nilable(T::Boolean), + last_reset_time: T.nilable(Google::Protobuf::Timestamp), + original_start_time: T.nilable(Google::Protobuf::Timestamp), + reset_run_id: T.nilable(String), + request_id_infos: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Workflow::V1::RequestIdInfo)]), + pause_info: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionPauseInfo) + ).void + end + def initialize( + execution_expiration_time: nil, + run_expiration_time: nil, + cancel_requested: false, + last_reset_time: nil, + original_start_time: nil, + reset_run_id: "", + request_id_infos: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Workflow::V1::RequestIdInfo), + pause_info: nil + ) + end + + # Workflow execution expiration time is defined as workflow start time plus expiration timeout. +# Workflow start time may change after workflow reset. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def execution_expiration_time + end + + # Workflow execution expiration time is defined as workflow start time plus expiration timeout. +# Workflow start time may change after workflow reset. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def execution_expiration_time=(value) + end + + # Workflow execution expiration time is defined as workflow start time plus expiration timeout. +# Workflow start time may change after workflow reset. + sig { void } + def clear_execution_expiration_time + end + + # Workflow run expiration time is defined as current workflow run start time plus workflow run timeout. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def run_expiration_time + end + + # Workflow run expiration time is defined as current workflow run start time plus workflow run timeout. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def run_expiration_time=(value) + end + + # Workflow run expiration time is defined as current workflow run start time plus workflow run timeout. + sig { void } + def clear_run_expiration_time + end + + # indicates if the workflow received a cancel request + sig { returns(T::Boolean) } + def cancel_requested + end + + # indicates if the workflow received a cancel request + sig { params(value: T::Boolean).void } + def cancel_requested=(value) + end + + # indicates if the workflow received a cancel request + sig { void } + def clear_cancel_requested + end + + # Last workflow reset time. Nil if the workflow was never reset. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_reset_time + end + + # Last workflow reset time. Nil if the workflow was never reset. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_reset_time=(value) + end + + # Last workflow reset time. Nil if the workflow was never reset. + sig { void } + def clear_last_reset_time + end + + # Original workflow start time. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def original_start_time + end + + # Original workflow start time. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def original_start_time=(value) + end + + # Original workflow start time. + sig { void } + def clear_original_start_time + end + + # Reset Run ID points to the new run when this execution is reset. If the execution is reset multiple times, it points to the latest run. + sig { returns(String) } + def reset_run_id + end + + # Reset Run ID points to the new run when this execution is reset. If the execution is reset multiple times, it points to the latest run. + sig { params(value: String).void } + def reset_run_id=(value) + end + + # Reset Run ID points to the new run when this execution is reset. If the execution is reset multiple times, it points to the latest run. + sig { void } + def clear_reset_run_id + end + + # Request ID information (eg: history event information associated with the request ID). +# Note: It only contains request IDs from StartWorkflowExecution requests, including indirect +# calls (eg: if SignalWithStartWorkflowExecution starts a new workflow, then the request ID is +# used in the StartWorkflowExecution request). + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Workflow::V1::RequestIdInfo)]) } + def request_id_infos + end + + # Request ID information (eg: history event information associated with the request ID). +# Note: It only contains request IDs from StartWorkflowExecution requests, including indirect +# calls (eg: if SignalWithStartWorkflowExecution starts a new workflow, then the request ID is +# used in the StartWorkflowExecution request). + sig { params(value: ::Google::Protobuf::Map).void } + def request_id_infos=(value) + end + + # Request ID information (eg: history event information associated with the request ID). +# Note: It only contains request IDs from StartWorkflowExecution requests, including indirect +# calls (eg: if SignalWithStartWorkflowExecution starts a new workflow, then the request ID is +# used in the StartWorkflowExecution request). + sig { void } + def clear_request_id_infos + end + + # Information about the workflow execution pause operation. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionPauseInfo)) } + def pause_info + end + + # Information about the workflow execution pause operation. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionPauseInfo)).void } + def pause_info=(value) + end + + # Information about the workflow execution pause operation. + sig { void } + def clear_pause_info + 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::Workflow::V1::WorkflowExecutionExtendedInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionExtendedInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::WorkflowExecutionExtendedInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionExtendedInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Holds all the information about worker versioning for a particular workflow execution. +# Experimental. Versioning info is experimental and might change in the future. +class Temporalio::Api::Workflow::V1::WorkflowExecutionVersioningInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + behavior: T.nilable(T.any(Symbol, String, Integer)), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + version: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + versioning_override: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride), + deployment_transition: T.nilable(Temporalio::Api::Workflow::V1::DeploymentTransition), + version_transition: T.nilable(Temporalio::Api::Workflow::V1::DeploymentVersionTransition), + revision_number: T.nilable(Integer), + continue_as_new_initial_versioning_behavior: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + behavior: :VERSIONING_BEHAVIOR_UNSPECIFIED, + deployment: nil, + version: "", + deployment_version: nil, + versioning_override: nil, + deployment_transition: nil, + version_transition: nil, + revision_number: 0, + continue_as_new_initial_versioning_behavior: :CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_UNSPECIFIED + ) + end + + # Versioning behavior determines how the server should treat this execution when workers are +# upgraded. When present it means this workflow execution is versioned; UNSPECIFIED means +# unversioned. See the comments in `VersioningBehavior` enum for more info about different +# behaviors. +# +# Child workflows or CaN executions **inherit** their parent/previous run's effective Versioning +# Behavior and Version (except when the new execution runs on a task queue not belonging to the +# same deployment version as the parent/previous run's task queue). The first workflow task will +# be dispatched according to the inherited behavior (or to the current version of the task-queue's +# deployment in the case of AutoUpgrade.) After completion of their first workflow task the +# Deployment Version and Behavior of the execution will update according to configuration on the worker. +# +# Note that `behavior` is overridden by `versioning_override` if the latter is present. + sig { returns(T.any(Symbol, Integer)) } + def behavior + end + + # Versioning behavior determines how the server should treat this execution when workers are +# upgraded. When present it means this workflow execution is versioned; UNSPECIFIED means +# unversioned. See the comments in `VersioningBehavior` enum for more info about different +# behaviors. +# +# Child workflows or CaN executions **inherit** their parent/previous run's effective Versioning +# Behavior and Version (except when the new execution runs on a task queue not belonging to the +# same deployment version as the parent/previous run's task queue). The first workflow task will +# be dispatched according to the inherited behavior (or to the current version of the task-queue's +# deployment in the case of AutoUpgrade.) After completion of their first workflow task the +# Deployment Version and Behavior of the execution will update according to configuration on the worker. +# +# Note that `behavior` is overridden by `versioning_override` if the latter is present. + sig { params(value: T.any(Symbol, String, Integer)).void } + def behavior=(value) + end + + # Versioning behavior determines how the server should treat this execution when workers are +# upgraded. When present it means this workflow execution is versioned; UNSPECIFIED means +# unversioned. See the comments in `VersioningBehavior` enum for more info about different +# behaviors. +# +# Child workflows or CaN executions **inherit** their parent/previous run's effective Versioning +# Behavior and Version (except when the new execution runs on a task queue not belonging to the +# same deployment version as the parent/previous run's task queue). The first workflow task will +# be dispatched according to the inherited behavior (or to the current version of the task-queue's +# deployment in the case of AutoUpgrade.) After completion of their first workflow task the +# Deployment Version and Behavior of the execution will update according to configuration on the worker. +# +# Note that `behavior` is overridden by `versioning_override` if the latter is present. + sig { void } + def clear_behavior + end + + # The worker deployment that completed the last workflow task of this workflow execution. Must +# be present if `behavior` is set. Absent value means no workflow task is completed, or the +# last workflow task was completed by an unversioned worker. Unversioned workers may still send +# a deployment value which will be stored here, so the right way to check if an execution is +# versioned if an execution is versioned or not is via the `behavior` field. +# Note that `deployment` is overridden by `versioning_override` if the latter is present. +# Deprecated. Use `deployment_version`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # The worker deployment that completed the last workflow task of this workflow execution. Must +# be present if `behavior` is set. Absent value means no workflow task is completed, or the +# last workflow task was completed by an unversioned worker. Unversioned workers may still send +# a deployment value which will be stored here, so the right way to check if an execution is +# versioned if an execution is versioned or not is via the `behavior` field. +# Note that `deployment` is overridden by `versioning_override` if the latter is present. +# Deprecated. Use `deployment_version`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # The worker deployment that completed the last workflow task of this workflow execution. Must +# be present if `behavior` is set. Absent value means no workflow task is completed, or the +# last workflow task was completed by an unversioned worker. Unversioned workers may still send +# a deployment value which will be stored here, so the right way to check if an execution is +# versioned if an execution is versioned or not is via the `behavior` field. +# Note that `deployment` is overridden by `versioning_override` if the latter is present. +# Deprecated. Use `deployment_version`. + sig { void } + def clear_deployment + end + + # Deprecated. Use `deployment_version`. + sig { returns(String) } + def version + end + + # Deprecated. Use `deployment_version`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `deployment_version`. + sig { void } + def clear_version + end + + # The Worker Deployment Version that completed the last workflow task of this workflow execution. +# An absent value means no workflow task is completed, or the workflow is unversioned. +# If present, and `behavior` is UNSPECIFIED, the last task of this workflow execution was completed +# by a worker that is not using versioning but _is_ passing Deployment Name and Build ID. +# +# Child workflows or CaN executions **inherit** their parent/previous run's effective Versioning +# Behavior and Version (except when the new execution runs on a task queue not belonging to the +# same deployment version as the parent/previous run's task queue). The first workflow task will +# be dispatched according to the inherited behavior (or to the current version of the task-queue's +# deployment in the case of AutoUpgrade.) After completion of their first workflow task the +# Deployment Version and Behavior of the execution will update according to configuration on the worker. +# +# Note that if `versioning_override.behavior` is PINNED then `versioning_override.pinned_version` +# will override this value. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # The Worker Deployment Version that completed the last workflow task of this workflow execution. +# An absent value means no workflow task is completed, or the workflow is unversioned. +# If present, and `behavior` is UNSPECIFIED, the last task of this workflow execution was completed +# by a worker that is not using versioning but _is_ passing Deployment Name and Build ID. +# +# Child workflows or CaN executions **inherit** their parent/previous run's effective Versioning +# Behavior and Version (except when the new execution runs on a task queue not belonging to the +# same deployment version as the parent/previous run's task queue). The first workflow task will +# be dispatched according to the inherited behavior (or to the current version of the task-queue's +# deployment in the case of AutoUpgrade.) After completion of their first workflow task the +# Deployment Version and Behavior of the execution will update according to configuration on the worker. +# +# Note that if `versioning_override.behavior` is PINNED then `versioning_override.pinned_version` +# will override this value. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # The Worker Deployment Version that completed the last workflow task of this workflow execution. +# An absent value means no workflow task is completed, or the workflow is unversioned. +# If present, and `behavior` is UNSPECIFIED, the last task of this workflow execution was completed +# by a worker that is not using versioning but _is_ passing Deployment Name and Build ID. +# +# Child workflows or CaN executions **inherit** their parent/previous run's effective Versioning +# Behavior and Version (except when the new execution runs on a task queue not belonging to the +# same deployment version as the parent/previous run's task queue). The first workflow task will +# be dispatched according to the inherited behavior (or to the current version of the task-queue's +# deployment in the case of AutoUpgrade.) After completion of their first workflow task the +# Deployment Version and Behavior of the execution will update according to configuration on the worker. +# +# Note that if `versioning_override.behavior` is PINNED then `versioning_override.pinned_version` +# will override this value. + sig { void } + def clear_deployment_version + end + + # Present if user has set an execution-specific versioning override. This override takes +# precedence over SDK-sent `behavior` (and `version` when override is PINNED). An +# override can be set when starting a new execution, as well as afterwards by calling the +# `UpdateWorkflowExecutionOptions` API. +# Pinned overrides are automatically inherited by child workflows, continue-as-new workflows, +# workflow retries, and cron workflows. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)) } + def versioning_override + end + + # Present if user has set an execution-specific versioning override. This override takes +# precedence over SDK-sent `behavior` (and `version` when override is PINNED). An +# override can be set when starting a new execution, as well as afterwards by calling the +# `UpdateWorkflowExecutionOptions` API. +# Pinned overrides are automatically inherited by child workflows, continue-as-new workflows, +# workflow retries, and cron workflows. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)).void } + def versioning_override=(value) + end + + # Present if user has set an execution-specific versioning override. This override takes +# precedence over SDK-sent `behavior` (and `version` when override is PINNED). An +# override can be set when starting a new execution, as well as afterwards by calling the +# `UpdateWorkflowExecutionOptions` API. +# Pinned overrides are automatically inherited by child workflows, continue-as-new workflows, +# workflow retries, and cron workflows. + sig { void } + def clear_versioning_override + end + + # When present, indicates the workflow is transitioning to a different deployment. Can +# indicate one of the following transitions: unversioned -> versioned, versioned -> versioned +# on a different deployment, or versioned -> unversioned. +# Not applicable to workflows with PINNED behavior. +# When a workflow with AUTO_UPGRADE behavior creates a new workflow task, it will automatically +# start a transition to the task queue's current deployment if the task queue's current +# deployment is different from the workflow's deployment. +# If the AUTO_UPGRADE workflow is stuck due to backlogged activity or workflow tasks, those +# tasks will be redirected to the task queue's current deployment. As soon as a poller from +# that deployment is available to receive the task, the workflow will automatically start a +# transition to that deployment and continue execution there. +# A deployment transition can only exist while there is a pending or started workflow task. +# Once the pending workflow task completes on the transition's target deployment, the +# transition completes and the workflow's `deployment` and `behavior` fields are updated per +# the worker's task completion response. +# Pending activities will not start new attempts during a transition. Once the transition is +# completed, pending activities will start their next attempt on the new deployment. +# Deprecated. Use version_transition. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::DeploymentTransition)) } + def deployment_transition + end + + # When present, indicates the workflow is transitioning to a different deployment. Can +# indicate one of the following transitions: unversioned -> versioned, versioned -> versioned +# on a different deployment, or versioned -> unversioned. +# Not applicable to workflows with PINNED behavior. +# When a workflow with AUTO_UPGRADE behavior creates a new workflow task, it will automatically +# start a transition to the task queue's current deployment if the task queue's current +# deployment is different from the workflow's deployment. +# If the AUTO_UPGRADE workflow is stuck due to backlogged activity or workflow tasks, those +# tasks will be redirected to the task queue's current deployment. As soon as a poller from +# that deployment is available to receive the task, the workflow will automatically start a +# transition to that deployment and continue execution there. +# A deployment transition can only exist while there is a pending or started workflow task. +# Once the pending workflow task completes on the transition's target deployment, the +# transition completes and the workflow's `deployment` and `behavior` fields are updated per +# the worker's task completion response. +# Pending activities will not start new attempts during a transition. Once the transition is +# completed, pending activities will start their next attempt on the new deployment. +# Deprecated. Use version_transition. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::DeploymentTransition)).void } + def deployment_transition=(value) + end + + # When present, indicates the workflow is transitioning to a different deployment. Can +# indicate one of the following transitions: unversioned -> versioned, versioned -> versioned +# on a different deployment, or versioned -> unversioned. +# Not applicable to workflows with PINNED behavior. +# When a workflow with AUTO_UPGRADE behavior creates a new workflow task, it will automatically +# start a transition to the task queue's current deployment if the task queue's current +# deployment is different from the workflow's deployment. +# If the AUTO_UPGRADE workflow is stuck due to backlogged activity or workflow tasks, those +# tasks will be redirected to the task queue's current deployment. As soon as a poller from +# that deployment is available to receive the task, the workflow will automatically start a +# transition to that deployment and continue execution there. +# A deployment transition can only exist while there is a pending or started workflow task. +# Once the pending workflow task completes on the transition's target deployment, the +# transition completes and the workflow's `deployment` and `behavior` fields are updated per +# the worker's task completion response. +# Pending activities will not start new attempts during a transition. Once the transition is +# completed, pending activities will start their next attempt on the new deployment. +# Deprecated. Use version_transition. + sig { void } + def clear_deployment_transition + end + + # When present, indicates the workflow is transitioning to a different deployment version +# (which may belong to the same deployment name or another). Can indicate one of the following +# transitions: unversioned -> versioned, versioned -> versioned +# on a different deployment version, or versioned -> unversioned. +# Not applicable to workflows with PINNED behavior. +# When a workflow with AUTO_UPGRADE behavior creates a new workflow task, it will automatically +# start a transition to the task queue's current version if the task queue's current version is +# different from the workflow's current deployment version. +# If the AUTO_UPGRADE workflow is stuck due to backlogged activity or workflow tasks, those +# tasks will be redirected to the task queue's current version. As soon as a poller from +# that deployment version is available to receive the task, the workflow will automatically +# start a transition to that version and continue execution there. +# A version transition can only exist while there is a pending or started workflow task. +# Once the pending workflow task completes on the transition's target version, the +# transition completes and the workflow's `behavior`, and `deployment_version` fields are updated per the +# worker's task completion response. +# Pending activities will not start new attempts during a transition. Once the transition is +# completed, pending activities will start their next attempt on the new version. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::DeploymentVersionTransition)) } + def version_transition + end + + # When present, indicates the workflow is transitioning to a different deployment version +# (which may belong to the same deployment name or another). Can indicate one of the following +# transitions: unversioned -> versioned, versioned -> versioned +# on a different deployment version, or versioned -> unversioned. +# Not applicable to workflows with PINNED behavior. +# When a workflow with AUTO_UPGRADE behavior creates a new workflow task, it will automatically +# start a transition to the task queue's current version if the task queue's current version is +# different from the workflow's current deployment version. +# If the AUTO_UPGRADE workflow is stuck due to backlogged activity or workflow tasks, those +# tasks will be redirected to the task queue's current version. As soon as a poller from +# that deployment version is available to receive the task, the workflow will automatically +# start a transition to that version and continue execution there. +# A version transition can only exist while there is a pending or started workflow task. +# Once the pending workflow task completes on the transition's target version, the +# transition completes and the workflow's `behavior`, and `deployment_version` fields are updated per the +# worker's task completion response. +# Pending activities will not start new attempts during a transition. Once the transition is +# completed, pending activities will start their next attempt on the new version. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::DeploymentVersionTransition)).void } + def version_transition=(value) + end + + # When present, indicates the workflow is transitioning to a different deployment version +# (which may belong to the same deployment name or another). Can indicate one of the following +# transitions: unversioned -> versioned, versioned -> versioned +# on a different deployment version, or versioned -> unversioned. +# Not applicable to workflows with PINNED behavior. +# When a workflow with AUTO_UPGRADE behavior creates a new workflow task, it will automatically +# start a transition to the task queue's current version if the task queue's current version is +# different from the workflow's current deployment version. +# If the AUTO_UPGRADE workflow is stuck due to backlogged activity or workflow tasks, those +# tasks will be redirected to the task queue's current version. As soon as a poller from +# that deployment version is available to receive the task, the workflow will automatically +# start a transition to that version and continue execution there. +# A version transition can only exist while there is a pending or started workflow task. +# Once the pending workflow task completes on the transition's target version, the +# transition completes and the workflow's `behavior`, and `deployment_version` fields are updated per the +# worker's task completion response. +# Pending activities will not start new attempts during a transition. Once the transition is +# completed, pending activities will start their next attempt on the new version. + sig { void } + def clear_version_transition + end + + # Monotonic counter reflecting the latest routing decision for this workflow execution. +# Used for staleness detection between history and matching when dispatching tasks to workers. +# Incremented when a workflow execution routes to a new deployment version, which happens +# when a worker of the new deployment version completes a workflow task. +# Note: Pinned tasks and sticky tasks send a value of 0 for this field since these tasks do not +# face the problem of inconsistent dispatching that arises from eventual consistency between +# task queues and their partitions. + sig { returns(Integer) } + def revision_number + end + + # Monotonic counter reflecting the latest routing decision for this workflow execution. +# Used for staleness detection between history and matching when dispatching tasks to workers. +# Incremented when a workflow execution routes to a new deployment version, which happens +# when a worker of the new deployment version completes a workflow task. +# Note: Pinned tasks and sticky tasks send a value of 0 for this field since these tasks do not +# face the problem of inconsistent dispatching that arises from eventual consistency between +# task queues and their partitions. + sig { params(value: Integer).void } + def revision_number=(value) + end + + # Monotonic counter reflecting the latest routing decision for this workflow execution. +# Used for staleness detection between history and matching when dispatching tasks to workers. +# Incremented when a workflow execution routes to a new deployment version, which happens +# when a worker of the new deployment version completes a workflow task. +# Note: Pinned tasks and sticky tasks send a value of 0 for this field since these tasks do not +# face the problem of inconsistent dispatching that arises from eventual consistency between +# task queues and their partitions. + sig { void } + def clear_revision_number + end + + # Experimental. +# If this workflow is the result of a continue-as-new, this field is set to the initial_versioning_behavior +# specified in that command. +# Only used for the initial task of this run and the initial task of any retries of this run. +# Not passed to children or to future continue-as-new. +# +# Note: In the first release of Upgrade-on-CaN, when the only ContinueAsNewVersioningBehavior was AutoUpgrade, +# a non-empty InheritedAutoUpgradeInfo meant that the workflow should start as AutoUpgrade. So for compatibility +# with ContinueAsNew history commands generated during that time, know that an UNSPECIFIED value here is equivalent +# to ContinueAsNewVersioningBehaviorAutoUpgrade if the behavior of the workflow is AutoUpgrade. + sig { returns(T.any(Symbol, Integer)) } + def continue_as_new_initial_versioning_behavior + end + + # Experimental. +# If this workflow is the result of a continue-as-new, this field is set to the initial_versioning_behavior +# specified in that command. +# Only used for the initial task of this run and the initial task of any retries of this run. +# Not passed to children or to future continue-as-new. +# +# Note: In the first release of Upgrade-on-CaN, when the only ContinueAsNewVersioningBehavior was AutoUpgrade, +# a non-empty InheritedAutoUpgradeInfo meant that the workflow should start as AutoUpgrade. So for compatibility +# with ContinueAsNew history commands generated during that time, know that an UNSPECIFIED value here is equivalent +# to ContinueAsNewVersioningBehaviorAutoUpgrade if the behavior of the workflow is AutoUpgrade. + sig { params(value: T.any(Symbol, String, Integer)).void } + def continue_as_new_initial_versioning_behavior=(value) + end + + # Experimental. +# If this workflow is the result of a continue-as-new, this field is set to the initial_versioning_behavior +# specified in that command. +# Only used for the initial task of this run and the initial task of any retries of this run. +# Not passed to children or to future continue-as-new. +# +# Note: In the first release of Upgrade-on-CaN, when the only ContinueAsNewVersioningBehavior was AutoUpgrade, +# a non-empty InheritedAutoUpgradeInfo meant that the workflow should start as AutoUpgrade. So for compatibility +# with ContinueAsNew history commands generated during that time, know that an UNSPECIFIED value here is equivalent +# to ContinueAsNewVersioningBehaviorAutoUpgrade if the behavior of the workflow is AutoUpgrade. + sig { void } + def clear_continue_as_new_initial_versioning_behavior + 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::Workflow::V1::WorkflowExecutionVersioningInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionVersioningInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::WorkflowExecutionVersioningInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionVersioningInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Holds information about ongoing transition of a workflow execution from one deployment to another. +# Deprecated. Use DeploymentVersionTransition. +class Temporalio::Api::Workflow::V1::DeploymentTransition + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment) + ).void + end + def initialize( + deployment: nil + ) + end + + # The target deployment of the transition. Null means a so-far-versioned workflow is +# transitioning to unversioned workers. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # The target deployment of the transition. Null means a so-far-versioned workflow is +# transitioning to unversioned workers. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # The target deployment of the transition. Null means a so-far-versioned workflow is +# transitioning to unversioned workers. + sig { void } + def clear_deployment + 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::Workflow::V1::DeploymentTransition) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::DeploymentTransition).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::DeploymentTransition) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::DeploymentTransition, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Holds information about ongoing transition of a workflow execution from one worker +# deployment version to another. +# Experimental. Might change in the future. +class Temporalio::Api::Workflow::V1::DeploymentVersionTransition + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + version: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion) + ).void + end + def initialize( + version: "", + deployment_version: nil + ) + end + + # Deprecated. Use `deployment_version`. + sig { returns(String) } + def version + end + + # Deprecated. Use `deployment_version`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `deployment_version`. + sig { void } + def clear_version + end + + # The target Version of the transition. +# If nil, a so-far-versioned workflow is transitioning to unversioned workers. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # The target Version of the transition. +# If nil, a so-far-versioned workflow is transitioning to unversioned workers. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # The target Version of the transition. +# If nil, a so-far-versioned workflow is transitioning to unversioned workers. + sig { void } + def clear_deployment_version + 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::Workflow::V1::DeploymentVersionTransition) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::DeploymentVersionTransition).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::DeploymentVersionTransition) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::DeploymentVersionTransition, 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::Workflow::V1::WorkflowExecutionConfig + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + default_workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata) + ).void + end + def initialize( + task_queue: nil, + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + default_workflow_task_timeout: nil, + user_metadata: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + sig { void } + def clear_workflow_execution_timeout + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + sig { void } + def clear_workflow_run_timeout + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def default_workflow_task_timeout + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def default_workflow_task_timeout=(value) + end + + sig { void } + def clear_default_workflow_task_timeout + end + + # User metadata provided on start workflow. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # User metadata provided on start workflow. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # User metadata provided on start workflow. + sig { void } + def clear_user_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::Workflow::V1::WorkflowExecutionConfig) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionConfig).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::WorkflowExecutionConfig) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionConfig, 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::Workflow::V1::PendingActivityInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_id: T.nilable(String), + activity_type: T.nilable(Temporalio::Api::Common::V1::ActivityType), + state: T.nilable(T.any(Symbol, String, Integer)), + heartbeat_details: T.nilable(Temporalio::Api::Common::V1::Payloads), + last_heartbeat_time: T.nilable(Google::Protobuf::Timestamp), + last_started_time: T.nilable(Google::Protobuf::Timestamp), + attempt: T.nilable(Integer), + maximum_attempts: T.nilable(Integer), + scheduled_time: T.nilable(Google::Protobuf::Timestamp), + expiration_time: T.nilable(Google::Protobuf::Timestamp), + last_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + last_worker_identity: T.nilable(String), + use_workflow_build_id: T.nilable(Google::Protobuf::Empty), + last_independently_assigned_build_id: T.nilable(String), + last_worker_version_stamp: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + current_retry_interval: T.nilable(Google::Protobuf::Duration), + last_attempt_complete_time: T.nilable(Google::Protobuf::Timestamp), + next_attempt_schedule_time: T.nilable(Google::Protobuf::Timestamp), + paused: T.nilable(T::Boolean), + last_deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + last_worker_deployment_version: T.nilable(String), + last_deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + pause_info: T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo), + activity_options: T.nilable(Temporalio::Api::Activity::V1::ActivityOptions) + ).void + end + def initialize( + activity_id: "", + activity_type: nil, + state: :PENDING_ACTIVITY_STATE_UNSPECIFIED, + heartbeat_details: nil, + last_heartbeat_time: nil, + last_started_time: nil, + attempt: 0, + maximum_attempts: 0, + scheduled_time: nil, + expiration_time: nil, + last_failure: nil, + last_worker_identity: "", + use_workflow_build_id: nil, + last_independently_assigned_build_id: "", + last_worker_version_stamp: nil, + current_retry_interval: nil, + last_attempt_complete_time: nil, + next_attempt_schedule_time: nil, + paused: false, + last_deployment: nil, + last_worker_deployment_version: "", + last_deployment_version: nil, + priority: nil, + pause_info: nil, + activity_options: nil + ) + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::ActivityType)) } + def activity_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ActivityType)).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def heartbeat_details + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def heartbeat_details=(value) + end + + sig { void } + def clear_heartbeat_details + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_heartbeat_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_heartbeat_time=(value) + end + + sig { void } + def clear_last_heartbeat_time + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_started_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_started_time=(value) + end + + sig { void } + def clear_last_started_time + end + + sig { returns(Integer) } + def attempt + end + + sig { params(value: Integer).void } + def attempt=(value) + end + + sig { void } + def clear_attempt + end + + sig { returns(Integer) } + def maximum_attempts + end + + sig { params(value: Integer).void } + def maximum_attempts=(value) + end + + sig { void } + def clear_maximum_attempts + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def scheduled_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def scheduled_time=(value) + end + + sig { void } + def clear_scheduled_time + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def expiration_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def expiration_time=(value) + end + + sig { void } + def clear_expiration_time + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_failure=(value) + end + + sig { void } + def clear_last_failure + end + + sig { returns(String) } + def last_worker_identity + end + + sig { params(value: String).void } + def last_worker_identity=(value) + end + + sig { void } + def clear_last_worker_identity + end + + # Deprecated. When present, it means this activity is assigned to the build ID of its workflow. + sig { returns(T.nilable(Google::Protobuf::Empty)) } + def use_workflow_build_id + end + + # Deprecated. When present, it means this activity is assigned to the build ID of its workflow. + sig { params(value: T.nilable(Google::Protobuf::Empty)).void } + def use_workflow_build_id=(value) + end + + # Deprecated. When present, it means this activity is assigned to the build ID of its workflow. + sig { void } + def clear_use_workflow_build_id + end + + # Deprecated. This means the activity is independently versioned and not bound to the build ID of its workflow. +# The activity will use the build id in this field instead. +# If the task fails and is scheduled again, the assigned build ID may change according to the latest versioning +# rules. + sig { returns(String) } + def last_independently_assigned_build_id + end + + # Deprecated. This means the activity is independently versioned and not bound to the build ID of its workflow. +# The activity will use the build id in this field instead. +# If the task fails and is scheduled again, the assigned build ID may change according to the latest versioning +# rules. + sig { params(value: String).void } + def last_independently_assigned_build_id=(value) + end + + # Deprecated. This means the activity is independently versioned and not bound to the build ID of its workflow. +# The activity will use the build id in this field instead. +# If the task fails and is scheduled again, the assigned build ID may change according to the latest versioning +# rules. + sig { void } + def clear_last_independently_assigned_build_id + end + + # Deprecated. The version stamp of the worker to whom this activity was most recently dispatched +# This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def last_worker_version_stamp + end + + # Deprecated. The version stamp of the worker to whom this activity was most recently dispatched +# This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def last_worker_version_stamp=(value) + end + + # Deprecated. The version stamp of the worker to whom this activity was most recently dispatched +# This field should be cleaned up when versioning-2 API is removed. [cleanup-experimental-wv] + sig { void } + def clear_last_worker_version_stamp + end + + # The time activity will wait until the next retry. +# If activity is currently running it will be next retry interval if activity failed. +# If activity is currently waiting it will be current retry interval. +# If there will be no retry it will be null. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def current_retry_interval + end + + # The time activity will wait until the next retry. +# If activity is currently running it will be next retry interval if activity failed. +# If activity is currently waiting it will be current retry interval. +# If there will be no retry it will be null. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def current_retry_interval=(value) + end + + # The time activity will wait until the next retry. +# If activity is currently running it will be next retry interval if activity failed. +# If activity is currently waiting it will be current retry interval. +# If there will be no retry it will be null. + sig { void } + def clear_current_retry_interval + end + + # The time when the last activity attempt was completed. If activity has not been completed yet then it will be null. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_attempt_complete_time + end + + # The time when the last activity attempt was completed. If activity has not been completed yet then it will be null. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_attempt_complete_time=(value) + end + + # The time when the last activity attempt was completed. If activity has not been completed yet then it will be null. + sig { void } + def clear_last_attempt_complete_time + end + + # Next time when activity will be scheduled. +# If activity is currently scheduled or started it will be null. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def next_attempt_schedule_time + end + + # Next time when activity will be scheduled. +# If activity is currently scheduled or started it will be null. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def next_attempt_schedule_time=(value) + end + + # Next time when activity will be scheduled. +# If activity is currently scheduled or started it will be null. + sig { void } + def clear_next_attempt_schedule_time + end + + # Indicates if activity is paused. + sig { returns(T::Boolean) } + def paused + end + + # Indicates if activity is paused. + sig { params(value: T::Boolean).void } + def paused=(value) + end + + # Indicates if activity is paused. + sig { void } + def clear_paused + end + + # The deployment this activity was dispatched to most recently. Present only if the activity +# was dispatched to a versioned worker. +# Deprecated. Use `last_deployment_version`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def last_deployment + end + + # The deployment this activity was dispatched to most recently. Present only if the activity +# was dispatched to a versioned worker. +# Deprecated. Use `last_deployment_version`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def last_deployment=(value) + end + + # The deployment this activity was dispatched to most recently. Present only if the activity +# was dispatched to a versioned worker. +# Deprecated. Use `last_deployment_version`. + sig { void } + def clear_last_deployment + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# Deprecated. Use `last_deployment_version`. + sig { returns(String) } + def last_worker_deployment_version + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# Deprecated. Use `last_deployment_version`. + sig { params(value: String).void } + def last_worker_deployment_version=(value) + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# Deprecated. Use `last_deployment_version`. + sig { void } + def clear_last_worker_deployment_version + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# If nil, the activity has not yet been dispatched or was last dispatched to an unversioned worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def last_deployment_version + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# If nil, the activity has not yet been dispatched or was last dispatched to an unversioned worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def last_deployment_version=(value) + end + + # The Worker Deployment Version this activity was dispatched to most recently. +# If nil, the activity has not yet been dispatched or was last dispatched to an unversioned worker. + sig { void } + def clear_last_deployment_version + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata. If this message is not present, or any fields are not +# present, they inherit the values from the workflow. + sig { void } + def clear_priority + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo)) } + def pause_info + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo)).void } + def pause_info=(value) + end + + sig { void } + def clear_pause_info + end + + # Current activity options. May be different from the one used to start the activity. + sig { returns(T.nilable(Temporalio::Api::Activity::V1::ActivityOptions)) } + def activity_options + end + + # Current activity options. May be different from the one used to start the activity. + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::ActivityOptions)).void } + def activity_options=(value) + end + + # Current activity options. May be different from the one used to start the activity. + sig { void } + def clear_activity_options + end + + sig { returns(T.nilable(Symbol)) } + def assigned_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::Workflow::V1::PendingActivityInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingActivityInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PendingActivityInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingActivityInfo, 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::Workflow::V1::PendingChildExecutionInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_id: T.nilable(String), + run_id: T.nilable(String), + workflow_type_name: T.nilable(String), + initiated_id: T.nilable(Integer), + parent_close_policy: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + workflow_id: "", + run_id: "", + workflow_type_name: "", + initiated_id: 0, + parent_close_policy: :PARENT_CLOSE_POLICY_UNSPECIFIED + ) + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { returns(String) } + def workflow_type_name + end + + sig { params(value: String).void } + def workflow_type_name=(value) + end + + sig { void } + def clear_workflow_type_name + end + + sig { returns(Integer) } + def initiated_id + end + + sig { params(value: Integer).void } + def initiated_id=(value) + end + + sig { void } + def clear_initiated_id + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { returns(T.any(Symbol, Integer)) } + def parent_close_policy + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def parent_close_policy=(value) + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { void } + def clear_parent_close_policy + 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::Workflow::V1::PendingChildExecutionInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingChildExecutionInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PendingChildExecutionInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingChildExecutionInfo, 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::Workflow::V1::PendingWorkflowTaskInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + state: T.nilable(T.any(Symbol, String, Integer)), + scheduled_time: T.nilable(Google::Protobuf::Timestamp), + original_scheduled_time: T.nilable(Google::Protobuf::Timestamp), + started_time: T.nilable(Google::Protobuf::Timestamp), + attempt: T.nilable(Integer) + ).void + end + def initialize( + state: :PENDING_WORKFLOW_TASK_STATE_UNSPECIFIED, + scheduled_time: nil, + original_scheduled_time: nil, + started_time: nil, + attempt: 0 + ) + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def scheduled_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def scheduled_time=(value) + end + + sig { void } + def clear_scheduled_time + end + + # original_scheduled_time is the scheduled time of the first workflow task during workflow task heartbeat. +# Heartbeat workflow task is done by RespondWorkflowTaskComplete with ForceCreateNewWorkflowTask == true and no command +# In this case, OriginalScheduledTime won't change. Then when current time - original_scheduled_time exceeds +# some threshold, the workflow task will be forced timeout. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def original_scheduled_time + end + + # original_scheduled_time is the scheduled time of the first workflow task during workflow task heartbeat. +# Heartbeat workflow task is done by RespondWorkflowTaskComplete with ForceCreateNewWorkflowTask == true and no command +# In this case, OriginalScheduledTime won't change. Then when current time - original_scheduled_time exceeds +# some threshold, the workflow task will be forced timeout. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def original_scheduled_time=(value) + end + + # original_scheduled_time is the scheduled time of the first workflow task during workflow task heartbeat. +# Heartbeat workflow task is done by RespondWorkflowTaskComplete with ForceCreateNewWorkflowTask == true and no command +# In this case, OriginalScheduledTime won't change. Then when current time - original_scheduled_time exceeds +# some threshold, the workflow task will be forced timeout. + sig { void } + def clear_original_scheduled_time + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def started_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def started_time=(value) + end + + sig { void } + def clear_started_time + end + + sig { returns(Integer) } + def attempt + end + + sig { params(value: Integer).void } + def attempt=(value) + end + + sig { void } + def clear_attempt + 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::Workflow::V1::PendingWorkflowTaskInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingWorkflowTaskInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PendingWorkflowTaskInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingWorkflowTaskInfo, 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::Workflow::V1::ResetPoints + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + points: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::ResetPointInfo)]) + ).void + end + def initialize( + points: [] + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::ResetPointInfo)]) } + def points + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def points=(value) + end + + sig { void } + def clear_points + 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::Workflow::V1::ResetPoints) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::ResetPoints).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::ResetPoints) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::ResetPoints, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# ResetPointInfo records the workflow event id that is the first one processed by a given +# build id or binary checksum. A new reset point will be created if either build id or binary +# checksum changes (although in general only one or the other will be used at a time). +class Temporalio::Api::Workflow::V1::ResetPointInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + build_id: T.nilable(String), + binary_checksum: T.nilable(String), + run_id: T.nilable(String), + first_workflow_task_completed_id: T.nilable(Integer), + create_time: T.nilable(Google::Protobuf::Timestamp), + expire_time: T.nilable(Google::Protobuf::Timestamp), + resettable: T.nilable(T::Boolean) + ).void + end + def initialize( + build_id: "", + binary_checksum: "", + run_id: "", + first_workflow_task_completed_id: 0, + create_time: nil, + expire_time: nil, + resettable: false + ) + end + + # Worker build id. + sig { returns(String) } + def build_id + end + + # Worker build id. + sig { params(value: String).void } + def build_id=(value) + end + + # Worker build id. + sig { void } + def clear_build_id + end + + # Deprecated. A worker binary version identifier. + sig { returns(String) } + def binary_checksum + end + + # Deprecated. A worker binary version identifier. + sig { params(value: String).void } + def binary_checksum=(value) + end + + # Deprecated. A worker binary version identifier. + sig { void } + def clear_binary_checksum + end + + # The first run ID in the execution chain that was touched by this worker build. + sig { returns(String) } + def run_id + end + + # The first run ID in the execution chain that was touched by this worker build. + sig { params(value: String).void } + def run_id=(value) + end + + # The first run ID in the execution chain that was touched by this worker build. + sig { void } + def clear_run_id + end + + # Event ID of the first WorkflowTaskCompleted event processed by this worker build. + sig { returns(Integer) } + def first_workflow_task_completed_id + end + + # Event ID of the first WorkflowTaskCompleted event processed by this worker build. + sig { params(value: Integer).void } + def first_workflow_task_completed_id=(value) + end + + # Event ID of the first WorkflowTaskCompleted event processed by this worker build. + sig { void } + def clear_first_workflow_task_completed_id + 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 + + # (-- api-linter: core::0214::resource-expiry=disabled +# aip.dev/not-precedent: TTL is not defined for ResetPointInfo. --) +# The time that the run is deleted due to retention. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def expire_time + end + + # (-- api-linter: core::0214::resource-expiry=disabled +# aip.dev/not-precedent: TTL is not defined for ResetPointInfo. --) +# The time that the run is deleted due to retention. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def expire_time=(value) + end + + # (-- api-linter: core::0214::resource-expiry=disabled +# aip.dev/not-precedent: TTL is not defined for ResetPointInfo. --) +# The time that the run is deleted due to retention. + sig { void } + def clear_expire_time + end + + # false if the reset point has pending childWFs/reqCancels/signalExternals. + sig { returns(T::Boolean) } + def resettable + end + + # false if the reset point has pending childWFs/reqCancels/signalExternals. + sig { params(value: T::Boolean).void } + def resettable=(value) + end + + # false if the reset point has pending childWFs/reqCancels/signalExternals. + sig { void } + def clear_resettable + 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::Workflow::V1::ResetPointInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::ResetPointInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::ResetPointInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::ResetPointInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# NewWorkflowExecutionInfo is a shared message that encapsulates all the +# required arguments to starting a workflow in different contexts. +class Temporalio::Api::Workflow::V1::NewWorkflowExecutionInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_id: T.nilable(String), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + workflow_id_reuse_policy: T.nilable(T.any(Symbol, String, Integer)), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + header: T.nilable(Temporalio::Api::Common::V1::Header), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + versioning_override: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride), + priority: T.nilable(Temporalio::Api::Common::V1::Priority) + ).void + end + def initialize( + workflow_id: "", + workflow_type: nil, + task_queue: nil, + input: nil, + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + workflow_id_reuse_policy: :WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED, + retry_policy: nil, + cron_schedule: "", + memo: nil, + search_attributes: nil, + header: nil, + user_metadata: nil, + versioning_override: nil, + priority: nil + ) + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + # Serialized arguments to the workflow. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized arguments to the workflow. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized arguments to the workflow. + sig { void } + def clear_input + end + + # Total workflow execution timeout including retries and continue as new. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + # Total workflow execution timeout including retries and continue as new. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + # Total workflow execution timeout including retries and continue as new. + sig { void } + def clear_workflow_execution_timeout + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { returns(T.any(Symbol, Integer)) } + def workflow_id_reuse_policy + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def workflow_id_reuse_policy=(value) + end + + # Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { void } + def clear_workflow_id_reuse_policy + end + + # The retry policy for the workflow. Will never exceed `workflow_execution_timeout`. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # The retry policy for the workflow. Will never exceed `workflow_execution_timeout`. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # The retry policy for the workflow. Will never exceed `workflow_execution_timeout`. + sig { void } + def clear_retry_policy + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { returns(String) } + def cron_schedule + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { params(value: String).void } + def cron_schedule=(value) + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { void } + def clear_cron_schedule + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionConfig +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionConfig +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionConfig +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { void } + def clear_user_metadata + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)) } + def versioning_override + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)).void } + def versioning_override=(value) + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { void } + def clear_versioning_override + end + + # Priority metadata + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata + sig { void } + def clear_priority + 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::Workflow::V1::NewWorkflowExecutionInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::NewWorkflowExecutionInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::NewWorkflowExecutionInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::NewWorkflowExecutionInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# CallbackInfo contains the state of an attached workflow callback. +class Temporalio::Api::Workflow::V1::CallbackInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + callback: T.nilable(Temporalio::Api::Common::V1::Callback), + trigger: T.nilable(Temporalio::Api::Workflow::V1::CallbackInfo::Trigger), + registration_time: T.nilable(Google::Protobuf::Timestamp), + state: T.nilable(T.any(Symbol, String, Integer)), + attempt: T.nilable(Integer), + last_attempt_complete_time: T.nilable(Google::Protobuf::Timestamp), + last_attempt_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + next_attempt_schedule_time: T.nilable(Google::Protobuf::Timestamp), + blocked_reason: T.nilable(String) + ).void + end + def initialize( + callback: nil, + trigger: nil, + registration_time: nil, + state: :CALLBACK_STATE_UNSPECIFIED, + attempt: 0, + last_attempt_complete_time: nil, + last_attempt_failure: nil, + next_attempt_schedule_time: nil, + blocked_reason: "" + ) + end + + # Information on how this callback should be invoked (e.g. its URL and type). + sig { returns(T.nilable(Temporalio::Api::Common::V1::Callback)) } + def callback + end + + # Information on how this callback should be invoked (e.g. its URL and type). + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Callback)).void } + def callback=(value) + end + + # Information on how this callback should be invoked (e.g. its URL and type). + sig { void } + def clear_callback + end + + # Trigger for this callback. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::CallbackInfo::Trigger)) } + def trigger + end + + # Trigger for this callback. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::CallbackInfo::Trigger)).void } + def trigger=(value) + end + + # Trigger for this callback. + sig { void } + def clear_trigger + end + + # The time when the callback was registered. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def registration_time + end + + # The time when the callback was registered. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def registration_time=(value) + end + + # The time when the callback was registered. + sig { void } + def clear_registration_time + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + end + + # The number of attempts made to deliver the callback. +# This number represents a minimum bound since the attempt is incremented after the callback request completes. + sig { returns(Integer) } + def attempt + end + + # The number of attempts made to deliver the callback. +# This number represents a minimum bound since the attempt is incremented after the callback request completes. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The number of attempts made to deliver the callback. +# This number represents a minimum bound since the attempt is incremented after the callback request completes. + sig { void } + def clear_attempt + end + + # The time when the last attempt completed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_attempt_complete_time + end + + # The time when the last attempt completed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_attempt_complete_time=(value) + end + + # The time when the last attempt completed. + sig { void } + def clear_last_attempt_complete_time + end + + # The last attempt's failure, if any. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_attempt_failure + end + + # The last attempt's failure, if any. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_attempt_failure=(value) + end + + # The last attempt's failure, if any. + sig { void } + def clear_last_attempt_failure + end + + # The time when the next attempt is scheduled. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def next_attempt_schedule_time + end + + # The time when the next attempt is scheduled. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def next_attempt_schedule_time=(value) + end + + # The time when the next attempt is scheduled. + sig { void } + def clear_next_attempt_schedule_time + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { returns(String) } + def blocked_reason + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { params(value: String).void } + def blocked_reason=(value) + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { void } + def clear_blocked_reason + 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::Workflow::V1::CallbackInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::CallbackInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::CallbackInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::CallbackInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# PendingNexusOperationInfo contains the state of a pending Nexus operation. +class Temporalio::Api::Workflow::V1::PendingNexusOperationInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + endpoint: T.nilable(String), + service: T.nilable(String), + operation: T.nilable(String), + operation_id: T.nilable(String), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + scheduled_time: T.nilable(Google::Protobuf::Timestamp), + state: T.nilable(T.any(Symbol, String, Integer)), + attempt: T.nilable(Integer), + last_attempt_complete_time: T.nilable(Google::Protobuf::Timestamp), + last_attempt_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + next_attempt_schedule_time: T.nilable(Google::Protobuf::Timestamp), + cancellation_info: T.nilable(Temporalio::Api::Workflow::V1::NexusOperationCancellationInfo), + scheduled_event_id: T.nilable(Integer), + blocked_reason: T.nilable(String), + operation_token: T.nilable(String), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + endpoint: "", + service: "", + operation: "", + operation_id: "", + schedule_to_close_timeout: nil, + scheduled_time: nil, + state: :PENDING_NEXUS_OPERATION_STATE_UNSPECIFIED, + attempt: 0, + last_attempt_complete_time: nil, + last_attempt_failure: nil, + next_attempt_schedule_time: nil, + cancellation_info: nil, + scheduled_event_id: 0, + blocked_reason: "", + operation_token: "", + schedule_to_start_timeout: nil, + start_to_close_timeout: nil + ) + end + + # Endpoint name. +# Resolved to a URL via the cluster's endpoint registry. + sig { returns(String) } + def endpoint + end + + # Endpoint name. +# Resolved to a URL via the cluster's endpoint registry. + sig { params(value: String).void } + def endpoint=(value) + end + + # Endpoint name. +# Resolved to a URL via the cluster's endpoint registry. + sig { void } + def clear_endpoint + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Operation name. + sig { returns(String) } + def operation + end + + # Operation name. + sig { params(value: String).void } + def operation=(value) + end + + # Operation name. + sig { void } + def clear_operation + end + + # Operation ID. Only set for asynchronous operations after a successful StartOperation call. +# +# Deprecated. Renamed to operation_token. + sig { returns(String) } + def operation_id + end + + # Operation ID. Only set for asynchronous operations after a successful StartOperation call. +# +# Deprecated. Renamed to operation_token. + sig { params(value: String).void } + def operation_id=(value) + end + + # Operation ID. Only set for asynchronous operations after a successful StartOperation call. +# +# Deprecated. Renamed to operation_token. + sig { void } + def clear_operation_id + end + + # Schedule-to-close timeout for this operation. +# This is the only timeout settable by a workflow. +# (-- 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_close_timeout + end + + # Schedule-to-close timeout for this operation. +# This is the only timeout settable by a workflow. +# (-- 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_close_timeout=(value) + end + + # Schedule-to-close timeout for this operation. +# This is the only timeout settable by a workflow. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # The time when the operation was scheduled. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def scheduled_time + end + + # The time when the operation was scheduled. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def scheduled_time=(value) + end + + # The time when the operation was scheduled. + sig { void } + def clear_scheduled_time + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + end + + # The number of attempts made to deliver the start operation request. +# This number is approximate, it is incremented when a task is added to the history queue. +# In practice, there could be more attempts if a task is executed but fails to commit, or less attempts if a task +# was never executed. + sig { returns(Integer) } + def attempt + end + + # The number of attempts made to deliver the start operation request. +# This number is approximate, it is incremented when a task is added to the history queue. +# In practice, there could be more attempts if a task is executed but fails to commit, or less attempts if a task +# was never executed. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The number of attempts made to deliver the start operation request. +# This number is approximate, it is incremented when a task is added to the history queue. +# In practice, there could be more attempts if a task is executed but fails to commit, or less attempts if a task +# was never executed. + sig { void } + def clear_attempt + end + + # The time when the last attempt completed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_attempt_complete_time + end + + # The time when the last attempt completed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_attempt_complete_time=(value) + end + + # The time when the last attempt completed. + sig { void } + def clear_last_attempt_complete_time + end + + # The last attempt's failure, if any. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_attempt_failure + end + + # The last attempt's failure, if any. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_attempt_failure=(value) + end + + # The last attempt's failure, if any. + sig { void } + def clear_last_attempt_failure + end + + # The time when the next attempt is scheduled. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def next_attempt_schedule_time + end + + # The time when the next attempt is scheduled. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def next_attempt_schedule_time=(value) + end + + # The time when the next attempt is scheduled. + sig { void } + def clear_next_attempt_schedule_time + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::NexusOperationCancellationInfo)) } + def cancellation_info + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::NexusOperationCancellationInfo)).void } + def cancellation_info=(value) + end + + sig { void } + def clear_cancellation_info + end + + # The event ID of the NexusOperationScheduled event. Can be used to correlate an operation in the +# DescribeWorkflowExecution response with workflow history. + sig { returns(Integer) } + def scheduled_event_id + end + + # The event ID of the NexusOperationScheduled event. Can be used to correlate an operation in the +# DescribeWorkflowExecution response with workflow history. + sig { params(value: Integer).void } + def scheduled_event_id=(value) + end + + # The event ID of the NexusOperationScheduled event. Can be used to correlate an operation in the +# DescribeWorkflowExecution response with workflow history. + sig { void } + def clear_scheduled_event_id + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { returns(String) } + def blocked_reason + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { params(value: String).void } + def blocked_reason=(value) + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { void } + def clear_blocked_reason + end + + # Operation token. Only set for asynchronous operations after a successful StartOperation call. + sig { returns(String) } + def operation_token + end + + # Operation token. Only set for asynchronous operations after a successful StartOperation call. + sig { params(value: String).void } + def operation_token=(value) + end + + # Operation token. Only set for asynchronous operations after a successful StartOperation call. + sig { void } + def clear_operation_token + end + + # Schedule-to-start timeout for this operation. +# (-- 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 + + # Schedule-to-start timeout for this operation. +# (-- 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 + + # Schedule-to-start timeout for this operation. +# (-- 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 + + # Start-to-close timeout for this operation. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Start-to-close timeout for this operation. +# (-- 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 start_to_close_timeout=(value) + end + + # Start-to-close timeout for this operation. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_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::Workflow::V1::PendingNexusOperationInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingNexusOperationInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PendingNexusOperationInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingNexusOperationInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# NexusOperationCancellationInfo contains the state of a nexus operation cancellation. +class Temporalio::Api::Workflow::V1::NexusOperationCancellationInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + requested_time: T.nilable(Google::Protobuf::Timestamp), + state: T.nilable(T.any(Symbol, String, Integer)), + attempt: T.nilable(Integer), + last_attempt_complete_time: T.nilable(Google::Protobuf::Timestamp), + last_attempt_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + next_attempt_schedule_time: T.nilable(Google::Protobuf::Timestamp), + blocked_reason: T.nilable(String) + ).void + end + def initialize( + requested_time: nil, + state: :NEXUS_OPERATION_CANCELLATION_STATE_UNSPECIFIED, + attempt: 0, + last_attempt_complete_time: nil, + last_attempt_failure: nil, + next_attempt_schedule_time: nil, + blocked_reason: "" + ) + end + + # The time when cancellation was requested. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def requested_time + end + + # The time when cancellation was requested. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def requested_time=(value) + end + + # The time when cancellation was requested. + sig { void } + def clear_requested_time + end + + sig { returns(T.any(Symbol, Integer)) } + def state + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + sig { void } + def clear_state + end + + # The number of attempts made to deliver the cancel operation request. +# This number represents a minimum bound since the attempt is incremented after the request completes. + sig { returns(Integer) } + def attempt + end + + # The number of attempts made to deliver the cancel operation request. +# This number represents a minimum bound since the attempt is incremented after the request completes. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The number of attempts made to deliver the cancel operation request. +# This number represents a minimum bound since the attempt is incremented after the request completes. + sig { void } + def clear_attempt + end + + # The time when the last attempt completed. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_attempt_complete_time + end + + # The time when the last attempt completed. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_attempt_complete_time=(value) + end + + # The time when the last attempt completed. + sig { void } + def clear_last_attempt_complete_time + end + + # The last attempt's failure, if any. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def last_attempt_failure + end + + # The last attempt's failure, if any. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def last_attempt_failure=(value) + end + + # The last attempt's failure, if any. + sig { void } + def clear_last_attempt_failure + end + + # The time when the next attempt is scheduled. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def next_attempt_schedule_time + end + + # The time when the next attempt is scheduled. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def next_attempt_schedule_time=(value) + end + + # The time when the next attempt is scheduled. + sig { void } + def clear_next_attempt_schedule_time + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { returns(String) } + def blocked_reason + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { params(value: String).void } + def blocked_reason=(value) + end + + # If the state is BLOCKED, blocked reason provides additional information. + sig { void } + def clear_blocked_reason + 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::Workflow::V1::NexusOperationCancellationInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::NexusOperationCancellationInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::NexusOperationCancellationInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::NexusOperationCancellationInfo, 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::Workflow::V1::WorkflowExecutionOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + versioning_override: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + time_skipping_config: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig) + ).void + end + def initialize( + versioning_override: nil, + priority: nil, + time_skipping_config: nil + ) + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)) } + def versioning_override + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)).void } + def versioning_override=(value) + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. + sig { void } + def clear_versioning_override + end + + # If set, overrides the workflow's priority sent by the SDK. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # If set, overrides the workflow's priority sent by the SDK. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # If set, overrides the workflow's priority sent by the SDK. + sig { void } + def clear_priority + end + + # Time-skipping configuration for this workflow execution. +# If not set, the time-skipping configuration is not updated by this request; +# the existing configuration is preserved. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)) } + def time_skipping_config + end + + # Time-skipping configuration for this workflow execution. +# If not set, the time-skipping configuration is not updated by this request; +# the existing configuration is preserved. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)).void } + def time_skipping_config=(value) + end + + # Time-skipping configuration for this workflow execution. +# If not set, the time-skipping configuration is not updated by this request; +# the existing configuration is preserved. + sig { void } + def clear_time_skipping_config + 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::Workflow::V1::WorkflowExecutionOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Configuration for time skipping during a workflow execution. +# When enabled, virtual time advances automatically whenever there is no in-flight work. +# In-flight work includes activities, child workflows, Nexus operations, signal/cancel external workflow operations, +# and possibly other features added in the future. +# User timers are not classified as in-flight work and will be skipped over. +# When time advances, it skips to the earlier of the next user timer or the configured bound, if either exists. +# +# Propagation behavior of time skipping: +# The enabled flag, bound fields, and accumulated skipped duration are propagated to related executions as follows: +# (1) Child workflows and continue-as-new: both the configuration and the accumulated skipped duration are +# inherited from the current execution. The configured bound is shared between the inherited skipped +# duration and any additional duration skipped by the new run. +# (2) Retry and cron: the configuration and accumulated skipped duration are inherited as recorded when the +# current workflow started; the accumulated skipped duration of the current run is not propagated. +# (3) Reset: the new run retains the time-skipping configuration of the current execution. Because reset replays +# all events up to the reset point and re-applies any UpdateWorkflowExecutionOptions changes made after that +# point, the resulting run ends up with the same final time-skipping configuration as the previous run. +class Temporalio::Api::Workflow::V1::TimeSkippingConfig + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + enabled: T.nilable(T::Boolean), + max_skipped_duration: T.nilable(Google::Protobuf::Duration), + max_elapsed_duration: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + enabled: false, + max_skipped_duration: nil, + max_elapsed_duration: nil + ) + end + + # Enables or disables time skipping for this workflow execution. + sig { returns(T::Boolean) } + def enabled + end + + # Enables or disables time skipping for this workflow execution. + sig { params(value: T::Boolean).void } + def enabled=(value) + end + + # Enables or disables time skipping for this workflow execution. + sig { void } + def clear_enabled + end + + # Maximum total virtual time that can be skipped. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def max_skipped_duration + end + + # Maximum total virtual time that can be skipped. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def max_skipped_duration=(value) + end + + # Maximum total virtual time that can be skipped. + sig { void } + def clear_max_skipped_duration + end + + # Maximum elapsed time since time skipping was enabled. +# This includes both skipped time and real time elapsing. +# (-- api-linter: core::0142::time-field-names=disabled --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def max_elapsed_duration + end + + # Maximum elapsed time since time skipping was enabled. +# This includes both skipped time and real time elapsing. +# (-- api-linter: core::0142::time-field-names=disabled --) + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def max_elapsed_duration=(value) + end + + # Maximum elapsed time since time skipping was enabled. +# This includes both skipped time and real time elapsing. +# (-- api-linter: core::0142::time-field-names=disabled --) + sig { void } + def clear_max_elapsed_duration + end + + sig { returns(T.nilable(Symbol)) } + def bound + 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::Workflow::V1::TimeSkippingConfig) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::TimeSkippingConfig).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::TimeSkippingConfig) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::TimeSkippingConfig, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used to override the versioning behavior (and pinned deployment version, if applicable) of a +# specific workflow execution. If set, this override takes precedence over worker-sent values. +# See `WorkflowExecutionInfo.VersioningInfo` for more information. +# +# To remove the override, call `UpdateWorkflowExecutionOptions` with a null +# `VersioningOverride`, and use the `update_mask` to indicate that it should be mutated. +# +# Pinned behavior overrides are automatically inherited by child workflows, workflow retries, continue-as-new +# workflows, and cron workflows. +class Temporalio::Api::Workflow::V1::VersioningOverride + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + pinned: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride::PinnedOverride), + auto_upgrade: T.nilable(T::Boolean), + behavior: T.nilable(T.any(Symbol, String, Integer)), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + pinned_version: T.nilable(String) + ).void + end + def initialize( + pinned: nil, + auto_upgrade: false, + behavior: :VERSIONING_BEHAVIOR_UNSPECIFIED, + deployment: nil, + pinned_version: "" + ) + end + + # Override the workflow to have Pinned behavior. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride::PinnedOverride)) } + def pinned + end + + # Override the workflow to have Pinned behavior. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride::PinnedOverride)).void } + def pinned=(value) + end + + # Override the workflow to have Pinned behavior. + sig { void } + def clear_pinned + end + + # Override the workflow to have AutoUpgrade behavior. + sig { returns(T::Boolean) } + def auto_upgrade + end + + # Override the workflow to have AutoUpgrade behavior. + sig { params(value: T::Boolean).void } + def auto_upgrade=(value) + end + + # Override the workflow to have AutoUpgrade behavior. + sig { void } + def clear_auto_upgrade + end + + # Required. +# Deprecated. Use `override`. + sig { returns(T.any(Symbol, Integer)) } + def behavior + end + + # Required. +# Deprecated. Use `override`. + sig { params(value: T.any(Symbol, String, Integer)).void } + def behavior=(value) + end + + # Required. +# Deprecated. Use `override`. + sig { void } + def clear_behavior + end + + # Required if behavior is `PINNED`. Must be null if behavior is `AUTO_UPGRADE`. +# Identifies the worker deployment to pin the workflow to. +# Deprecated. Use `override.pinned.version`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # Required if behavior is `PINNED`. Must be null if behavior is `AUTO_UPGRADE`. +# Identifies the worker deployment to pin the workflow to. +# Deprecated. Use `override.pinned.version`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # Required if behavior is `PINNED`. Must be null if behavior is `AUTO_UPGRADE`. +# Identifies the worker deployment to pin the workflow to. +# Deprecated. Use `override.pinned.version`. + sig { void } + def clear_deployment + end + + # Required if behavior is `PINNED`. Must be absent if behavior is not `PINNED`. +# Identifies the worker deployment version to pin the workflow to, in the format +# ".". +# Deprecated. Use `override.pinned.version`. + sig { returns(String) } + def pinned_version + end + + # Required if behavior is `PINNED`. Must be absent if behavior is not `PINNED`. +# Identifies the worker deployment version to pin the workflow to, in the format +# ".". +# Deprecated. Use `override.pinned.version`. + sig { params(value: String).void } + def pinned_version=(value) + end + + # Required if behavior is `PINNED`. Must be absent if behavior is not `PINNED`. +# Identifies the worker deployment version to pin the workflow to, in the format +# ".". +# Deprecated. Use `override.pinned.version`. + sig { void } + def clear_pinned_version + end + + sig { returns(T.nilable(Symbol)) } + def override + 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::Workflow::V1::VersioningOverride) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::VersioningOverride).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::VersioningOverride) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::VersioningOverride, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# When StartWorkflowExecution uses the conflict policy WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING and +# there is already an existing running workflow, OnConflictOptions defines actions to be taken on +# the existing running workflow. In this case, it will create a WorkflowExecutionOptionsUpdatedEvent +# history event in the running workflow with the changes requested in this object. +class Temporalio::Api::Workflow::V1::OnConflictOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + attach_request_id: T.nilable(T::Boolean), + attach_completion_callbacks: T.nilable(T::Boolean), + attach_links: T.nilable(T::Boolean) + ).void + end + def initialize( + attach_request_id: false, + attach_completion_callbacks: false, + attach_links: false + ) + end + + # Attaches the request ID to the running workflow. + sig { returns(T::Boolean) } + def attach_request_id + end + + # Attaches the request ID to the running workflow. + sig { params(value: T::Boolean).void } + def attach_request_id=(value) + end + + # Attaches the request ID to the running workflow. + sig { void } + def clear_attach_request_id + end + + # Attaches the completion callbacks to the running workflow. + sig { returns(T::Boolean) } + def attach_completion_callbacks + end + + # Attaches the completion callbacks to the running workflow. + sig { params(value: T::Boolean).void } + def attach_completion_callbacks=(value) + end + + # Attaches the completion callbacks to the running workflow. + sig { void } + def clear_attach_completion_callbacks + end + + # Attaches the links to the WorkflowExecutionOptionsUpdatedEvent history event. + sig { returns(T::Boolean) } + def attach_links + end + + # Attaches the links to the WorkflowExecutionOptionsUpdatedEvent history event. + sig { params(value: T::Boolean).void } + def attach_links=(value) + end + + # Attaches the links to the WorkflowExecutionOptionsUpdatedEvent history event. + sig { void } + def clear_attach_links + 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::Workflow::V1::OnConflictOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::OnConflictOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::OnConflictOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::OnConflictOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# RequestIdInfo contains details of a request ID. +class Temporalio::Api::Workflow::V1::RequestIdInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + event_type: T.nilable(T.any(Symbol, String, Integer)), + event_id: T.nilable(Integer), + buffered: T.nilable(T::Boolean) + ).void + end + def initialize( + event_type: :EVENT_TYPE_UNSPECIFIED, + event_id: 0, + buffered: false + ) + end + + # The event type of the history event generated by the request. + sig { returns(T.any(Symbol, Integer)) } + def event_type + end + + # The event type of the history event generated by the request. + sig { params(value: T.any(Symbol, String, Integer)).void } + def event_type=(value) + end + + # The event type of the history event generated by the request. + sig { void } + def clear_event_type + end + + # The event id of the history event generated by the request. It's possible the event ID is not +# known (unflushed buffered event). In this case, the value will be zero or a negative value, +# representing an invalid ID. + sig { returns(Integer) } + def event_id + end + + # The event id of the history event generated by the request. It's possible the event ID is not +# known (unflushed buffered event). In this case, the value will be zero or a negative value, +# representing an invalid ID. + sig { params(value: Integer).void } + def event_id=(value) + end + + # The event id of the history event generated by the request. It's possible the event ID is not +# known (unflushed buffered event). In this case, the value will be zero or a negative value, +# representing an invalid ID. + sig { void } + def clear_event_id + end + + # Indicate if the request is still buffered. If so, the event ID is not known and its value +# will be an invalid event ID. + sig { returns(T::Boolean) } + def buffered + end + + # Indicate if the request is still buffered. If so, the event ID is not known and its value +# will be an invalid event ID. + sig { params(value: T::Boolean).void } + def buffered=(value) + end + + # Indicate if the request is still buffered. If so, the event ID is not known and its value +# will be an invalid event ID. + sig { void } + def clear_buffered + 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::Workflow::V1::RequestIdInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::RequestIdInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::RequestIdInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::RequestIdInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# PostResetOperation represents an operation to be performed on the new workflow execution after a workflow reset. +class Temporalio::Api::Workflow::V1::PostResetOperation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + signal_workflow: T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation::SignalWorkflow), + update_workflow_options: T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation::UpdateWorkflowOptions) + ).void + end + def initialize( + signal_workflow: nil, + update_workflow_options: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation::SignalWorkflow)) } + def signal_workflow + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation::SignalWorkflow)).void } + def signal_workflow=(value) + end + + sig { void } + def clear_signal_workflow + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation::UpdateWorkflowOptions)) } + def update_workflow_options + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation::UpdateWorkflowOptions)).void } + def update_workflow_options=(value) + end + + sig { void } + def clear_update_workflow_options + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Workflow::V1::PostResetOperation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PostResetOperation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PostResetOperation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PostResetOperation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# WorkflowExecutionPauseInfo contains the information about a workflow execution pause. +class Temporalio::Api::Workflow::V1::WorkflowExecutionPauseInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + paused_time: T.nilable(Google::Protobuf::Timestamp), + reason: T.nilable(String) + ).void + end + def initialize( + identity: "", + paused_time: nil, + reason: "" + ) + end + + # The identity of the client who paused the workflow execution. + sig { returns(String) } + def identity + end + + # The identity of the client who paused the workflow execution. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who paused the workflow execution. + sig { void } + def clear_identity + end + + # The time when the workflow execution was paused. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def paused_time + end + + # The time when the workflow execution was paused. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def paused_time=(value) + end + + # The time when the workflow execution was paused. + sig { void } + def clear_paused_time + end + + # The reason for pausing the workflow execution. + sig { returns(String) } + def reason + end + + # The reason for pausing the workflow execution. + sig { params(value: String).void } + def reason=(value) + end + + # The reason for pausing the workflow execution. + sig { void } + def clear_reason + 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::Workflow::V1::WorkflowExecutionPauseInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionPauseInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::WorkflowExecutionPauseInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::WorkflowExecutionPauseInfo, 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::Workflow::V1::PendingActivityInfo::PauseInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + pause_time: T.nilable(Google::Protobuf::Timestamp), + manual: T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Manual), + rule: T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Rule) + ).void + end + def initialize( + pause_time: nil, + manual: nil, + rule: nil + ) + end + + # The time when the activity was paused. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def pause_time + end + + # The time when the activity was paused. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def pause_time=(value) + end + + # The time when the activity was paused. + sig { void } + def clear_pause_time + end + + # activity was paused by the manual intervention + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Manual)) } + def manual + end + + # activity was paused by the manual intervention + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Manual)).void } + def manual=(value) + end + + # activity was paused by the manual intervention + sig { void } + def clear_manual + end + + # activity was paused by the rule + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Rule)) } + def rule + end + + # activity was paused by the rule + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Rule)).void } + def rule=(value) + end + + # activity was paused by the rule + sig { void } + def clear_rule + end + + sig { returns(T.nilable(Symbol)) } + def paused_by + 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::Workflow::V1::PendingActivityInfo::PauseInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo, 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::Workflow::V1::PendingActivityInfo::PauseInfo::Manual + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + identity: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + identity: "", + reason: "" + ) + end + + # The identity of the actor that paused the activity. + sig { returns(String) } + def identity + end + + # The identity of the actor that paused the activity. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the actor that paused the activity. + sig { void } + def clear_identity + end + + # Reason for pausing the activity. + sig { returns(String) } + def reason + end + + # Reason for pausing the activity. + sig { params(value: String).void } + def reason=(value) + end + + # Reason for pausing the activity. + sig { void } + def clear_reason + 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::Workflow::V1::PendingActivityInfo::PauseInfo::Manual) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Manual).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Manual) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Manual, 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::Workflow::V1::PendingActivityInfo::PauseInfo::Rule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rule_id: T.nilable(String), + identity: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + rule_id: "", + identity: "", + reason: "" + ) + end + + # The rule that paused the activity. + sig { returns(String) } + def rule_id + end + + # The rule that paused the activity. + sig { params(value: String).void } + def rule_id=(value) + end + + # The rule that paused the activity. + sig { void } + def clear_rule_id + end + + # The identity of the actor that created the rule. + sig { returns(String) } + def identity + end + + # The identity of the actor that created the rule. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the actor that created the rule. + sig { void } + def clear_identity + end + + # Reason why rule was created. Populated from rule description. + sig { returns(String) } + def reason + end + + # Reason why rule was created. Populated from rule description. + sig { params(value: String).void } + def reason=(value) + end + + # Reason why rule was created. Populated from rule description. + sig { void } + def clear_reason + 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::Workflow::V1::PendingActivityInfo::PauseInfo::Rule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Rule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Rule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PendingActivityInfo::PauseInfo::Rule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Trigger for when the workflow is closed. +class Temporalio::Api::Workflow::V1::CallbackInfo::WorkflowClosed + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Workflow::V1::CallbackInfo::WorkflowClosed) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::CallbackInfo::WorkflowClosed).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::CallbackInfo::WorkflowClosed) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::CallbackInfo::WorkflowClosed, 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::Workflow::V1::CallbackInfo::Trigger + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_closed: T.nilable(Temporalio::Api::Workflow::V1::CallbackInfo::WorkflowClosed) + ).void + end + def initialize( + workflow_closed: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::CallbackInfo::WorkflowClosed)) } + def workflow_closed + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::CallbackInfo::WorkflowClosed)).void } + def workflow_closed=(value) + end + + sig { void } + def clear_workflow_closed + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Workflow::V1::CallbackInfo::Trigger) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::CallbackInfo::Trigger).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::CallbackInfo::Trigger) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::CallbackInfo::Trigger, 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::Workflow::V1::VersioningOverride::PinnedOverride + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + behavior: T.nilable(T.any(Symbol, String, Integer)), + version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion) + ).void + end + def initialize( + behavior: :PINNED_OVERRIDE_BEHAVIOR_UNSPECIFIED, + version: nil + ) + end + + # Defaults to PINNED_OVERRIDE_BEHAVIOR_UNSPECIFIED. +# See `PinnedOverrideBehavior` for details. + sig { returns(T.any(Symbol, Integer)) } + def behavior + end + + # Defaults to PINNED_OVERRIDE_BEHAVIOR_UNSPECIFIED. +# See `PinnedOverrideBehavior` for details. + sig { params(value: T.any(Symbol, String, Integer)).void } + def behavior=(value) + end + + # Defaults to PINNED_OVERRIDE_BEHAVIOR_UNSPECIFIED. +# See `PinnedOverrideBehavior` for details. + sig { void } + def clear_behavior + end + + # Specifies the Worker Deployment Version to pin this workflow to. +# Required if the target workflow is not already pinned to a version. +# +# If omitted and the target workflow is already pinned, the effective +# pinned version will be the existing pinned version. +# +# If omitted and the target workflow is not pinned, the override request +# will be rejected with a PreconditionFailed error. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def version + end + + # Specifies the Worker Deployment Version to pin this workflow to. +# Required if the target workflow is not already pinned to a version. +# +# If omitted and the target workflow is already pinned, the effective +# pinned version will be the existing pinned version. +# +# If omitted and the target workflow is not pinned, the override request +# will be rejected with a PreconditionFailed error. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def version=(value) + end + + # Specifies the Worker Deployment Version to pin this workflow to. +# Required if the target workflow is not already pinned to a version. +# +# If omitted and the target workflow is already pinned, the effective +# pinned version will be the existing pinned version. +# +# If omitted and the target workflow is not pinned, the override request +# will be rejected with a PreconditionFailed error. + sig { void } + def clear_version + 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::Workflow::V1::VersioningOverride::PinnedOverride) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::VersioningOverride::PinnedOverride).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::VersioningOverride::PinnedOverride) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::VersioningOverride::PinnedOverride, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# SignalWorkflow represents sending a signal after a workflow reset. +# Keep the parameter in sync with temporal.api.workflowservice.v1.SignalWorkflowExecutionRequest. +class Temporalio::Api::Workflow::V1::PostResetOperation::SignalWorkflow + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + signal_name: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + header: T.nilable(Temporalio::Api::Common::V1::Header), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) + ).void + end + def initialize( + signal_name: "", + input: nil, + header: nil, + links: [] + ) + end + + # The workflow author-defined name of the signal to send to the workflow. + sig { returns(String) } + def signal_name + end + + # The workflow author-defined name of the signal to send to the workflow. + sig { params(value: String).void } + def signal_name=(value) + end + + # The workflow author-defined name of the signal to send to the workflow. + sig { void } + def clear_signal_name + end + + # Serialized value(s) to provide with the signal. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized value(s) to provide with the signal. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized value(s) to provide with the signal. + sig { void } + def clear_input + end + + # Headers that are passed with the signal to the processing workflow. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Headers that are passed with the signal to the processing workflow. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Headers that are passed with the signal to the processing workflow. + sig { void } + def clear_header + end + + # Links to be associated with the WorkflowExecutionSignaled event. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to be associated with the WorkflowExecutionSignaled event. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to be associated with the WorkflowExecutionSignaled event. + sig { void } + def clear_links + 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::Workflow::V1::PostResetOperation::SignalWorkflow) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PostResetOperation::SignalWorkflow).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PostResetOperation::SignalWorkflow) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PostResetOperation::SignalWorkflow, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# UpdateWorkflowOptions represents updating workflow execution options after a workflow reset. +# Keep the parameters in sync with temporal.api.workflowservice.v1.UpdateWorkflowExecutionOptionsRequest. +class Temporalio::Api::Workflow::V1::PostResetOperation::UpdateWorkflowOptions + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_execution_options: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions), + update_mask: T.nilable(Google::Protobuf::FieldMask) + ).void + end + def initialize( + workflow_execution_options: nil, + update_mask: nil + ) + end + + # Update Workflow options that were originally specified via StartWorkflowExecution. Partial updates are accepted and controlled by update_mask. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions)) } + def workflow_execution_options + end + + # Update Workflow options that were originally specified via StartWorkflowExecution. Partial updates are accepted and controlled by update_mask. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions)).void } + def workflow_execution_options=(value) + end + + # Update Workflow options that were originally specified via StartWorkflowExecution. Partial updates are accepted and controlled by update_mask. + sig { void } + def clear_workflow_execution_options + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { returns(T.nilable(Google::Protobuf::FieldMask)) } + def update_mask + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { params(value: T.nilable(Google::Protobuf::FieldMask)).void } + def update_mask=(value) + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { void } + def clear_update_mask + 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::Workflow::V1::PostResetOperation::UpdateWorkflowOptions) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PostResetOperation::UpdateWorkflowOptions).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::Workflow::V1::PostResetOperation::UpdateWorkflowOptions) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::Workflow::V1::PostResetOperation::UpdateWorkflowOptions, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Api::Workflow::V1::VersioningOverride::PinnedOverrideBehavior + self::PINNED_OVERRIDE_BEHAVIOR_UNSPECIFIED = T.let(0, Integer) + self::PINNED_OVERRIDE_BEHAVIOR_PINNED = T.let(1, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/workflowservice.rbi b/temporalio/rbi/temporalio/api/workflowservice.rbi new file mode 100644 index 00000000..af978404 --- /dev/null +++ b/temporalio/rbi/temporalio/api/workflowservice.rbi @@ -0,0 +1,5 @@ +# typed: true + +# Generated code. DO NOT EDIT! + +module Temporalio::Api::WorkflowService; end diff --git a/temporalio/rbi/temporalio/api/workflowservice/v1/request_response.rbi b/temporalio/rbi/temporalio/api/workflowservice/v1/request_response.rbi new file mode 100644 index 00000000..b806edcd --- /dev/null +++ b/temporalio/rbi/temporalio/api/workflowservice/v1/request_response.rbi @@ -0,0 +1,29121 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/workflowservice/v1/request_response.proto +# typed: strict + +class Temporalio::Api::WorkflowService::V1::RegisterNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + description: T.nilable(String), + owner_email: T.nilable(String), + workflow_execution_retention_period: T.nilable(Google::Protobuf::Duration), + clusters: T.nilable(T::Array[T.nilable(Temporalio::Api::Replication::V1::ClusterReplicationConfig)]), + active_cluster_name: T.nilable(String), + data: T.nilable(T::Hash[String, String]), + security_token: T.nilable(String), + is_global_namespace: T.nilable(T::Boolean), + history_archival_state: T.nilable(T.any(Symbol, String, Integer)), + history_archival_uri: T.nilable(String), + visibility_archival_state: T.nilable(T.any(Symbol, String, Integer)), + visibility_archival_uri: T.nilable(String) + ).void + end + def initialize( + namespace: "", + description: "", + owner_email: "", + workflow_execution_retention_period: nil, + clusters: [], + active_cluster_name: "", + data: ::Google::Protobuf::Map.new(:string, :string), + security_token: "", + is_global_namespace: false, + history_archival_state: :ARCHIVAL_STATE_UNSPECIFIED, + history_archival_uri: "", + visibility_archival_state: :ARCHIVAL_STATE_UNSPECIFIED, + visibility_archival_uri: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def description + end + + sig { params(value: String).void } + def description=(value) + end + + sig { void } + def clear_description + end + + sig { returns(String) } + def owner_email + end + + sig { params(value: String).void } + def owner_email=(value) + end + + sig { void } + def clear_owner_email + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_retention_period + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_retention_period=(value) + end + + sig { void } + def clear_workflow_execution_retention_period + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Replication::V1::ClusterReplicationConfig)]) } + def clusters + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def clusters=(value) + end + + sig { void } + def clear_clusters + end + + sig { returns(String) } + def active_cluster_name + end + + sig { params(value: String).void } + def active_cluster_name=(value) + end + + sig { void } + def clear_active_cluster_name + end + + # A key-value map for any customized purpose. + sig { returns(T::Hash[String, String]) } + def data + end + + # A key-value map for any customized purpose. + sig { params(value: ::Google::Protobuf::Map).void } + def data=(value) + end + + # A key-value map for any customized purpose. + sig { void } + def clear_data + end + + sig { returns(String) } + def security_token + end + + sig { params(value: String).void } + def security_token=(value) + end + + sig { void } + def clear_security_token + end + + sig { returns(T::Boolean) } + def is_global_namespace + end + + sig { params(value: T::Boolean).void } + def is_global_namespace=(value) + end + + sig { void } + def clear_is_global_namespace + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { returns(T.any(Symbol, Integer)) } + def history_archival_state + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { params(value: T.any(Symbol, String, Integer)).void } + def history_archival_state=(value) + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { void } + def clear_history_archival_state + end + + sig { returns(String) } + def history_archival_uri + end + + sig { params(value: String).void } + def history_archival_uri=(value) + end + + sig { void } + def clear_history_archival_uri + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { returns(T.any(Symbol, Integer)) } + def visibility_archival_state + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { params(value: T.any(Symbol, String, Integer)).void } + def visibility_archival_state=(value) + end + + # If unspecified (ARCHIVAL_STATE_UNSPECIFIED) then default server configuration is used. + sig { void } + def clear_visibility_archival_state + end + + sig { returns(String) } + def visibility_archival_uri + end + + sig { params(value: String).void } + def visibility_archival_uri=(value) + end + + sig { void } + def clear_visibility_archival_uri + 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::WorkflowService::V1::RegisterNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RegisterNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RegisterNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RegisterNamespaceRequest, 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::WorkflowService::V1::RegisterNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RegisterNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RegisterNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RegisterNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RegisterNamespaceResponse, 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::WorkflowService::V1::ListNamespacesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + namespace_filter: T.nilable(Temporalio::Api::Namespace::V1::NamespaceFilter) + ).void + end + def initialize( + page_size: 0, + next_page_token: "", + namespace_filter: nil + ) + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::NamespaceFilter)) } + def namespace_filter + end + + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::NamespaceFilter)).void } + def namespace_filter=(value) + end + + sig { void } + def clear_namespace_filter + 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::WorkflowService::V1::ListNamespacesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListNamespacesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListNamespacesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListNamespacesRequest, 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::WorkflowService::V1::ListNamespacesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespaces: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::DescribeNamespaceResponse)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + namespaces: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::DescribeNamespaceResponse)]) } + def namespaces + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def namespaces=(value) + end + + sig { void } + def clear_namespaces + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListNamespacesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListNamespacesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListNamespacesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListNamespacesResponse, 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::WorkflowService::V1::DescribeNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def id + end + + sig { params(value: String).void } + def id=(value) + end + + sig { void } + def clear_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::WorkflowService::V1::DescribeNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeNamespaceRequest, 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::WorkflowService::V1::DescribeNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace_info: T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo), + config: T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig), + replication_config: T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig), + failover_version: T.nilable(Integer), + is_global_namespace: T.nilable(T::Boolean), + failover_history: T.nilable(T::Array[T.nilable(Temporalio::Api::Replication::V1::FailoverStatus)]) + ).void + end + def initialize( + namespace_info: nil, + config: nil, + replication_config: nil, + failover_version: 0, + is_global_namespace: false, + failover_history: [] + ) + end + + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo)) } + def namespace_info + end + + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo)).void } + def namespace_info=(value) + end + + sig { void } + def clear_namespace_info + end + + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig)) } + def config + end + + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig)).void } + def config=(value) + end + + sig { void } + def clear_config + end + + sig { returns(T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig)) } + def replication_config + end + + sig { params(value: T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig)).void } + def replication_config=(value) + end + + sig { void } + def clear_replication_config + end + + sig { returns(Integer) } + def failover_version + end + + sig { params(value: Integer).void } + def failover_version=(value) + end + + sig { void } + def clear_failover_version + end + + sig { returns(T::Boolean) } + def is_global_namespace + end + + sig { params(value: T::Boolean).void } + def is_global_namespace=(value) + end + + sig { void } + def clear_is_global_namespace + end + + # Contains the historical state of failover_versions for the cluster, truncated to contain only the last N +# states to ensure that the list does not grow unbounded. + sig { returns(T::Array[T.nilable(Temporalio::Api::Replication::V1::FailoverStatus)]) } + def failover_history + end + + # Contains the historical state of failover_versions for the cluster, truncated to contain only the last N +# states to ensure that the list does not grow unbounded. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def failover_history=(value) + end + + # Contains the historical state of failover_versions for the cluster, truncated to contain only the last N +# states to ensure that the list does not grow unbounded. + sig { void } + def clear_failover_history + 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::WorkflowService::V1::DescribeNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeNamespaceResponse, 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::WorkflowService::V1::UpdateNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + update_info: T.nilable(Temporalio::Api::Namespace::V1::UpdateNamespaceInfo), + config: T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig), + replication_config: T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig), + security_token: T.nilable(String), + delete_bad_binary: T.nilable(String), + promote_namespace: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace: "", + update_info: nil, + config: nil, + replication_config: nil, + security_token: "", + delete_bad_binary: "", + promote_namespace: false + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::UpdateNamespaceInfo)) } + def update_info + end + + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::UpdateNamespaceInfo)).void } + def update_info=(value) + end + + sig { void } + def clear_update_info + end + + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig)) } + def config + end + + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig)).void } + def config=(value) + end + + sig { void } + def clear_config + end + + sig { returns(T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig)) } + def replication_config + end + + sig { params(value: T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig)).void } + def replication_config=(value) + end + + sig { void } + def clear_replication_config + end + + sig { returns(String) } + def security_token + end + + sig { params(value: String).void } + def security_token=(value) + end + + sig { void } + def clear_security_token + end + + sig { returns(String) } + def delete_bad_binary + end + + sig { params(value: String).void } + def delete_bad_binary=(value) + end + + sig { void } + def clear_delete_bad_binary + end + + # promote local namespace to global namespace. Ignored if namespace is already global namespace. + sig { returns(T::Boolean) } + def promote_namespace + end + + # promote local namespace to global namespace. Ignored if namespace is already global namespace. + sig { params(value: T::Boolean).void } + def promote_namespace=(value) + end + + # promote local namespace to global namespace. Ignored if namespace is already global namespace. + sig { void } + def clear_promote_namespace + 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::WorkflowService::V1::UpdateNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateNamespaceRequest, 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::WorkflowService::V1::UpdateNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace_info: T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo), + config: T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig), + replication_config: T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig), + failover_version: T.nilable(Integer), + is_global_namespace: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace_info: nil, + config: nil, + replication_config: nil, + failover_version: 0, + is_global_namespace: false + ) + end + + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo)) } + def namespace_info + end + + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::NamespaceInfo)).void } + def namespace_info=(value) + end + + sig { void } + def clear_namespace_info + end + + sig { returns(T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig)) } + def config + end + + sig { params(value: T.nilable(Temporalio::Api::Namespace::V1::NamespaceConfig)).void } + def config=(value) + end + + sig { void } + def clear_config + end + + sig { returns(T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig)) } + def replication_config + end + + sig { params(value: T.nilable(Temporalio::Api::Replication::V1::NamespaceReplicationConfig)).void } + def replication_config=(value) + end + + sig { void } + def clear_replication_config + end + + sig { returns(Integer) } + def failover_version + end + + sig { params(value: Integer).void } + def failover_version=(value) + end + + sig { void } + def clear_failover_version + end + + sig { returns(T::Boolean) } + def is_global_namespace + end + + sig { params(value: T::Boolean).void } + def is_global_namespace=(value) + end + + sig { void } + def clear_is_global_namespace + 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::WorkflowService::V1::UpdateNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateNamespaceResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Deprecated. +class Temporalio::Api::WorkflowService::V1::DeprecateNamespaceRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + security_token: T.nilable(String) + ).void + end + def initialize( + namespace: "", + security_token: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def security_token + end + + sig { params(value: String).void } + def security_token=(value) + end + + sig { void } + def clear_security_token + 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::WorkflowService::V1::DeprecateNamespaceRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeprecateNamespaceRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeprecateNamespaceRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeprecateNamespaceRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Deprecated. +class Temporalio::Api::WorkflowService::V1::DeprecateNamespaceResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::DeprecateNamespaceResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeprecateNamespaceResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeprecateNamespaceResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeprecateNamespaceResponse, 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::WorkflowService::V1::StartWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + identity: T.nilable(String), + request_id: T.nilable(String), + workflow_id_reuse_policy: T.nilable(T.any(Symbol, String, Integer)), + workflow_id_conflict_policy: T.nilable(T.any(Symbol, String, Integer)), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + header: T.nilable(Temporalio::Api::Common::V1::Header), + request_eager_execution: T.nilable(T::Boolean), + continued_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + last_completion_result: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_start_delay: T.nilable(Google::Protobuf::Duration), + completion_callbacks: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Callback)]), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]), + versioning_override: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride), + on_conflict_options: T.nilable(Temporalio::Api::Workflow::V1::OnConflictOptions), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + eager_worker_deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions), + time_skipping_config: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + workflow_type: nil, + task_queue: nil, + input: nil, + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + identity: "", + request_id: "", + workflow_id_reuse_policy: :WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED, + workflow_id_conflict_policy: :WORKFLOW_ID_CONFLICT_POLICY_UNSPECIFIED, + retry_policy: nil, + cron_schedule: "", + memo: nil, + search_attributes: nil, + header: nil, + request_eager_execution: false, + continued_failure: nil, + last_completion_result: nil, + workflow_start_delay: nil, + completion_callbacks: [], + user_metadata: nil, + links: [], + versioning_override: nil, + on_conflict_options: nil, + priority: nil, + eager_worker_deployment_options: nil, + time_skipping_config: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + # Serialized arguments to the workflow. These are passed as arguments to the workflow function. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized arguments to the workflow. These are passed as arguments to the workflow function. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized arguments to the workflow. These are passed as arguments to the workflow function. + sig { void } + def clear_input + end + + # Total workflow execution timeout including retries and continue as new. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + # Total workflow execution timeout including retries and continue as new. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + # Total workflow execution timeout including retries and continue as new. + sig { void } + def clear_workflow_execution_timeout + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # The identity of the client who initiated this request + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request + sig { void } + def clear_identity + end + + # A unique identifier for this start request. Typically UUIDv4. + sig { returns(String) } + def request_id + end + + # A unique identifier for this start request. Typically UUIDv4. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this start request. Typically UUIDv4. + sig { void } + def clear_request_id + end + + # Defines whether to allow re-using the workflow id from a previously *closed* workflow. +# The default policy is WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. +# +# See `workflow_id_conflict_policy` for handling a workflow id duplication with a *running* workflow. + sig { returns(T.any(Symbol, Integer)) } + def workflow_id_reuse_policy + end + + # Defines whether to allow re-using the workflow id from a previously *closed* workflow. +# The default policy is WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. +# +# See `workflow_id_conflict_policy` for handling a workflow id duplication with a *running* workflow. + sig { params(value: T.any(Symbol, String, Integer)).void } + def workflow_id_reuse_policy=(value) + end + + # Defines whether to allow re-using the workflow id from a previously *closed* workflow. +# The default policy is WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. +# +# See `workflow_id_conflict_policy` for handling a workflow id duplication with a *running* workflow. + sig { void } + def clear_workflow_id_reuse_policy + end + + # Defines how to resolve a workflow id conflict with a *running* workflow. +# The default policy is WORKFLOW_ID_CONFLICT_POLICY_FAIL. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *closed* workflow. + sig { returns(T.any(Symbol, Integer)) } + def workflow_id_conflict_policy + end + + # Defines how to resolve a workflow id conflict with a *running* workflow. +# The default policy is WORKFLOW_ID_CONFLICT_POLICY_FAIL. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *closed* workflow. + sig { params(value: T.any(Symbol, String, Integer)).void } + def workflow_id_conflict_policy=(value) + end + + # Defines how to resolve a workflow id conflict with a *running* workflow. +# The default policy is WORKFLOW_ID_CONFLICT_POLICY_FAIL. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *closed* workflow. + sig { void } + def clear_workflow_id_conflict_policy + end + + # The retry policy for the workflow. Will never exceed `workflow_execution_timeout`. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # The retry policy for the workflow. Will never exceed `workflow_execution_timeout`. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # The retry policy for the workflow. Will never exceed `workflow_execution_timeout`. + sig { void } + def clear_retry_policy + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { returns(String) } + def cron_schedule + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { params(value: String).void } + def cron_schedule=(value) + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { void } + def clear_cron_schedule + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + # Request to get the first workflow task inline in the response bypassing matching service and worker polling. +# If set to `true` the caller is expected to have a worker available and capable of processing the task. +# The returned task will be marked as started and is expected to be completed by the specified +# `workflow_task_timeout`. + sig { returns(T::Boolean) } + def request_eager_execution + end + + # Request to get the first workflow task inline in the response bypassing matching service and worker polling. +# If set to `true` the caller is expected to have a worker available and capable of processing the task. +# The returned task will be marked as started and is expected to be completed by the specified +# `workflow_task_timeout`. + sig { params(value: T::Boolean).void } + def request_eager_execution=(value) + end + + # Request to get the first workflow task inline in the response bypassing matching service and worker polling. +# If set to `true` the caller is expected to have a worker available and capable of processing the task. +# The returned task will be marked as started and is expected to be completed by the specified +# `workflow_task_timeout`. + sig { void } + def clear_request_eager_execution + end + + # These values will be available as ContinuedFailure and LastCompletionResult in the +# WorkflowExecutionStarted event and through SDKs. The are currently only used by the +# server itself (for the schedules feature) and are not intended to be exposed in +# StartWorkflowExecution. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def continued_failure + end + + # These values will be available as ContinuedFailure and LastCompletionResult in the +# WorkflowExecutionStarted event and through SDKs. The are currently only used by the +# server itself (for the schedules feature) and are not intended to be exposed in +# StartWorkflowExecution. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def continued_failure=(value) + end + + # These values will be available as ContinuedFailure and LastCompletionResult in the +# WorkflowExecutionStarted event and through SDKs. The are currently only used by the +# server itself (for the schedules feature) and are not intended to be exposed in +# StartWorkflowExecution. + sig { void } + def clear_continued_failure + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_completion_result + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_completion_result=(value) + end + + sig { void } + def clear_last_completion_result + end + + # Time to wait before dispatching the first workflow task. Cannot be used with `cron_schedule`. +# If the workflow gets a signal before the delay, a workflow task will be dispatched and the rest +# of the delay will be ignored. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_start_delay + end + + # Time to wait before dispatching the first workflow task. Cannot be used with `cron_schedule`. +# If the workflow gets a signal before the delay, a workflow task will be dispatched and the rest +# of the delay will be ignored. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_start_delay=(value) + end + + # Time to wait before dispatching the first workflow task. Cannot be used with `cron_schedule`. +# If the workflow gets a signal before the delay, a workflow task will be dispatched and the rest +# of the delay will be ignored. + sig { void } + def clear_workflow_start_delay + end + + # Callbacks to be called by the server when this workflow reaches a terminal state. +# If the workflow continues-as-new, these callbacks will be carried over to the new execution. +# Callback addresses must be whitelisted in the server's dynamic configuration. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Callback)]) } + def completion_callbacks + end + + # Callbacks to be called by the server when this workflow reaches a terminal state. +# If the workflow continues-as-new, these callbacks will be carried over to the new execution. +# Callback addresses must be whitelisted in the server's dynamic configuration. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def completion_callbacks=(value) + end + + # Callbacks to be called by the server when this workflow reaches a terminal state. +# If the workflow continues-as-new, these callbacks will be carried over to the new execution. +# Callback addresses must be whitelisted in the server's dynamic configuration. + sig { void } + def clear_completion_callbacks + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionInfo +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionInfo +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionInfo +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { void } + def clear_user_metadata + end + + # Links to be associated with the workflow. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to be associated with the workflow. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to be associated with the workflow. + sig { void } + def clear_links + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)) } + def versioning_override + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)).void } + def versioning_override=(value) + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { void } + def clear_versioning_override + end + + # Defines actions to be done to the existing running workflow when the conflict policy +# WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING is used. If not set (ie., nil value) or set to a +# empty object (ie., all options with default value), it won't do anything to the existing +# running workflow. If set, it will add a history event to the running workflow. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::OnConflictOptions)) } + def on_conflict_options + end + + # Defines actions to be done to the existing running workflow when the conflict policy +# WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING is used. If not set (ie., nil value) or set to a +# empty object (ie., all options with default value), it won't do anything to the existing +# running workflow. If set, it will add a history event to the running workflow. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::OnConflictOptions)).void } + def on_conflict_options=(value) + end + + # Defines actions to be done to the existing running workflow when the conflict policy +# WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING is used. If not set (ie., nil value) or set to a +# empty object (ie., all options with default value), it won't do anything to the existing +# running workflow. If set, it will add a history event to the running workflow. + sig { void } + def clear_on_conflict_options + end + + # Priority metadata + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata + sig { void } + def clear_priority + end + + # Deployment Options of the worker who will process the eager task. Passed when `request_eager_execution=true`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def eager_worker_deployment_options + end + + # Deployment Options of the worker who will process the eager task. Passed when `request_eager_execution=true`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def eager_worker_deployment_options=(value) + end + + # Deployment Options of the worker who will process the eager task. Passed when `request_eager_execution=true`. + sig { void } + def clear_eager_worker_deployment_options + end + + # Time-skipping configuration. If not set, time skipping is disabled. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)) } + def time_skipping_config + end + + # Time-skipping configuration. If not set, time skipping is disabled. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)).void } + def time_skipping_config=(value) + end + + # Time-skipping configuration. If not set, time skipping is disabled. + sig { void } + def clear_time_skipping_config + 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::WorkflowService::V1::StartWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionRequest, 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::WorkflowService::V1::StartWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + started: T.nilable(T::Boolean), + status: T.nilable(T.any(Symbol, String, Integer)), + eager_workflow_task: T.nilable(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse), + link: T.nilable(Temporalio::Api::Common::V1::Link) + ).void + end + def initialize( + run_id: "", + started: false, + status: :WORKFLOW_EXECUTION_STATUS_UNSPECIFIED, + eager_workflow_task: nil, + link: nil + ) + end + + # The run id of the workflow that was started - or used (via WorkflowIdConflictPolicy USE_EXISTING). + sig { returns(String) } + def run_id + end + + # The run id of the workflow that was started - or used (via WorkflowIdConflictPolicy USE_EXISTING). + sig { params(value: String).void } + def run_id=(value) + end + + # The run id of the workflow that was started - or used (via WorkflowIdConflictPolicy USE_EXISTING). + sig { void } + def clear_run_id + end + + # If true, a new workflow was started. + sig { returns(T::Boolean) } + def started + end + + # If true, a new workflow was started. + sig { params(value: T::Boolean).void } + def started=(value) + end + + # If true, a new workflow was started. + sig { void } + def clear_started + end + + # Current execution status of the workflow. Typically remains WORKFLOW_EXECUTION_STATUS_RUNNING +# unless a de-dupe occurs or in specific scenarios handled within the ExecuteMultiOperation (refer to its docs). + sig { returns(T.any(Symbol, Integer)) } + def status + end + + # Current execution status of the workflow. Typically remains WORKFLOW_EXECUTION_STATUS_RUNNING +# unless a de-dupe occurs or in specific scenarios handled within the ExecuteMultiOperation (refer to its docs). + sig { params(value: T.any(Symbol, String, Integer)).void } + def status=(value) + end + + # Current execution status of the workflow. Typically remains WORKFLOW_EXECUTION_STATUS_RUNNING +# unless a de-dupe occurs or in specific scenarios handled within the ExecuteMultiOperation (refer to its docs). + sig { void } + def clear_status + end + + # When `request_eager_execution` is set on the `StartWorkflowExecutionRequest`, the server - if supported - will +# return the first workflow task to be eagerly executed. +# The caller is expected to have a worker available to process the task. + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse)) } + def eager_workflow_task + end + + # When `request_eager_execution` is set on the `StartWorkflowExecutionRequest`, the server - if supported - will +# return the first workflow task to be eagerly executed. +# The caller is expected to have a worker available to process the task. + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse)).void } + def eager_workflow_task=(value) + end + + # When `request_eager_execution` is set on the `StartWorkflowExecutionRequest`, the server - if supported - will +# return the first workflow task to be eagerly executed. +# The caller is expected to have a worker available to process the task. + sig { void } + def clear_eager_workflow_task + end + + # Link to the workflow event. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link)) } + def link + end + + # Link to the workflow event. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link)).void } + def link=(value) + end + + # Link to the workflow event. + sig { void } + def clear_link + 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::WorkflowService::V1::StartWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionResponse, 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::WorkflowService::V1::GetWorkflowExecutionHistoryRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + maximum_page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + wait_new_event: T.nilable(T::Boolean), + history_event_filter_type: T.nilable(T.any(Symbol, String, Integer)), + skip_archival: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace: "", + execution: nil, + maximum_page_size: 0, + next_page_token: "", + wait_new_event: false, + history_event_filter_type: :HISTORY_EVENT_FILTER_TYPE_UNSPECIFIED, + skip_archival: false + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + sig { void } + def clear_execution + end + + sig { returns(Integer) } + def maximum_page_size + end + + sig { params(value: Integer).void } + def maximum_page_size=(value) + end + + sig { void } + def clear_maximum_page_size + end + + # If a `GetWorkflowExecutionHistoryResponse` or a `PollWorkflowTaskQueueResponse` had one of +# these, it should be passed here to fetch the next page. + sig { returns(String) } + def next_page_token + end + + # If a `GetWorkflowExecutionHistoryResponse` or a `PollWorkflowTaskQueueResponse` had one of +# these, it should be passed here to fetch the next page. + sig { params(value: String).void } + def next_page_token=(value) + end + + # If a `GetWorkflowExecutionHistoryResponse` or a `PollWorkflowTaskQueueResponse` had one of +# these, it should be passed here to fetch the next page. + sig { void } + def clear_next_page_token + end + + # If set to true, the RPC call will not resolve until there is a new event which matches +# the `history_event_filter_type`, or a timeout is hit. + sig { returns(T::Boolean) } + def wait_new_event + end + + # If set to true, the RPC call will not resolve until there is a new event which matches +# the `history_event_filter_type`, or a timeout is hit. + sig { params(value: T::Boolean).void } + def wait_new_event=(value) + end + + # If set to true, the RPC call will not resolve until there is a new event which matches +# the `history_event_filter_type`, or a timeout is hit. + sig { void } + def clear_wait_new_event + end + + # Filter returned events such that they match the specified filter type. +# Default: HISTORY_EVENT_FILTER_TYPE_ALL_EVENT. + sig { returns(T.any(Symbol, Integer)) } + def history_event_filter_type + end + + # Filter returned events such that they match the specified filter type. +# Default: HISTORY_EVENT_FILTER_TYPE_ALL_EVENT. + sig { params(value: T.any(Symbol, String, Integer)).void } + def history_event_filter_type=(value) + end + + # Filter returned events such that they match the specified filter type. +# Default: HISTORY_EVENT_FILTER_TYPE_ALL_EVENT. + sig { void } + def clear_history_event_filter_type + end + + sig { returns(T::Boolean) } + def skip_archival + end + + sig { params(value: T::Boolean).void } + def skip_archival=(value) + end + + sig { void } + def clear_skip_archival + 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::WorkflowService::V1::GetWorkflowExecutionHistoryRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryRequest, 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::WorkflowService::V1::GetWorkflowExecutionHistoryResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + history: T.nilable(Temporalio::Api::History::V1::History), + raw_history: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::DataBlob)]), + next_page_token: T.nilable(String), + archived: T.nilable(T::Boolean) + ).void + end + def initialize( + history: nil, + raw_history: [], + next_page_token: "", + archived: false + ) + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::History)) } + def history + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::History)).void } + def history=(value) + end + + sig { void } + def clear_history + end + + # Raw history is an alternate representation of history that may be returned if configured on +# the frontend. This is not supported by all SDKs. Either this or `history` will be set. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::DataBlob)]) } + def raw_history + end + + # Raw history is an alternate representation of history that may be returned if configured on +# the frontend. This is not supported by all SDKs. Either this or `history` will be set. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def raw_history=(value) + end + + # Raw history is an alternate representation of history that may be returned if configured on +# the frontend. This is not supported by all SDKs. Either this or `history` will be set. + sig { void } + def clear_raw_history + end + + # Will be set if there are more history events than were included in this response + sig { returns(String) } + def next_page_token + end + + # Will be set if there are more history events than were included in this response + sig { params(value: String).void } + def next_page_token=(value) + end + + # Will be set if there are more history events than were included in this response + sig { void } + def clear_next_page_token + end + + sig { returns(T::Boolean) } + def archived + end + + sig { params(value: T::Boolean).void } + def archived=(value) + end + + sig { void } + def clear_archived + 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::WorkflowService::V1::GetWorkflowExecutionHistoryResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryResponse, 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::WorkflowService::V1::GetWorkflowExecutionHistoryReverseRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + maximum_page_size: T.nilable(Integer), + next_page_token: T.nilable(String) + ).void + end + def initialize( + namespace: "", + execution: nil, + maximum_page_size: 0, + next_page_token: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + sig { void } + def clear_execution + end + + sig { returns(Integer) } + def maximum_page_size + end + + sig { params(value: Integer).void } + def maximum_page_size=(value) + end + + sig { void } + def clear_maximum_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::GetWorkflowExecutionHistoryReverseRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryReverseRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryReverseRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryReverseRequest, 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::WorkflowService::V1::GetWorkflowExecutionHistoryReverseResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + history: T.nilable(Temporalio::Api::History::V1::History), + next_page_token: T.nilable(String) + ).void + end + def initialize( + history: nil, + next_page_token: "" + ) + end + + sig { returns(T.nilable(Temporalio::Api::History::V1::History)) } + def history + end + + sig { params(value: T.nilable(Temporalio::Api::History::V1::History)).void } + def history=(value) + end + + sig { void } + def clear_history + end + + # Will be set if there are more history events than were included in this response + sig { returns(String) } + def next_page_token + end + + # Will be set if there are more history events than were included in this response + sig { params(value: String).void } + def next_page_token=(value) + end + + # Will be set if there are more history events than were included in this response + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::GetWorkflowExecutionHistoryReverseResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryReverseResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryReverseResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryReverseResponse, 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::WorkflowService::V1::PollWorkflowTaskQueueRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + poller_group_id: T.nilable(String), + identity: T.nilable(String), + worker_instance_key: T.nilable(String), + worker_control_task_queue: T.nilable(String), + binary_checksum: T.nilable(String), + worker_version_capabilities: T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions) + ).void + end + def initialize( + namespace: "", + task_queue: nil, + poller_group_id: "", + identity: "", + worker_instance_key: "", + worker_control_task_queue: "", + binary_checksum: "", + worker_version_capabilities: nil, + deployment_options: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollWorkflowTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { returns(String) } + def poller_group_id + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollWorkflowTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { params(value: String).void } + def poller_group_id=(value) + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollWorkflowTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { void } + def clear_poller_group_id + end + + # The identity of the worker/client who is polling this task queue + sig { returns(String) } + def identity + end + + # The identity of the worker/client who is polling this task queue + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client who is polling this task queue + sig { void } + def clear_identity + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { returns(String) } + def worker_instance_key + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { void } + def clear_worker_instance_key + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { returns(String) } + def worker_control_task_queue + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { params(value: String).void } + def worker_control_task_queue=(value) + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { void } + def clear_worker_control_task_queue + end + + # Deprecated. Use deployment_options instead. +# Each worker process should provide an ID unique to the specific set of code it is running +# "checksum" in this field name isn't very accurate, it should be though of as an id. + sig { returns(String) } + def binary_checksum + end + + # Deprecated. Use deployment_options instead. +# Each worker process should provide an ID unique to the specific set of code it is running +# "checksum" in this field name isn't very accurate, it should be though of as an id. + sig { params(value: String).void } + def binary_checksum=(value) + end + + # Deprecated. Use deployment_options instead. +# Each worker process should provide an ID unique to the specific set of code it is running +# "checksum" in this field name isn't very accurate, it should be though of as an id. + sig { void } + def clear_binary_checksum + end + + # Deprecated. Use deployment_options instead. +# Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities)) } + def worker_version_capabilities + end + + # Deprecated. Use deployment_options instead. +# Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities)).void } + def worker_version_capabilities=(value) + end + + # Deprecated. Use deployment_options instead. +# Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. + sig { void } + def clear_worker_version_capabilities + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + 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::WorkflowService::V1::PollWorkflowTaskQueueRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueRequest, 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::WorkflowService::V1::PollWorkflowTaskQueueResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + previous_started_event_id: T.nilable(Integer), + started_event_id: T.nilable(Integer), + attempt: T.nilable(Integer), + backlog_count_hint: T.nilable(Integer), + history: T.nilable(Temporalio::Api::History::V1::History), + next_page_token: T.nilable(String), + query: T.nilable(Temporalio::Api::Query::V1::WorkflowQuery), + workflow_execution_task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + scheduled_time: T.nilable(Google::Protobuf::Timestamp), + started_time: T.nilable(Google::Protobuf::Timestamp), + queries: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Query::V1::WorkflowQuery)]), + messages: T.nilable(T::Array[T.nilable(Temporalio::Api::Protocol::V1::Message)]), + poller_scaling_decision: T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision), + poller_group_id: T.nilable(String), + poller_group_infos: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerGroupInfo)]) + ).void + end + def initialize( + task_token: "", + workflow_execution: nil, + workflow_type: nil, + previous_started_event_id: 0, + started_event_id: 0, + attempt: 0, + backlog_count_hint: 0, + history: nil, + next_page_token: "", + query: nil, + workflow_execution_task_queue: nil, + scheduled_time: nil, + started_time: nil, + queries: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Query::V1::WorkflowQuery), + messages: [], + poller_scaling_decision: nil, + poller_group_id: "", + poller_group_infos: [] + ) + end + + # A unique identifier for this task + sig { returns(String) } + def task_token + end + + # A unique identifier for this task + sig { params(value: String).void } + def task_token=(value) + end + + # A unique identifier for this task + sig { void } + def clear_task_token + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + # The last workflow task started event which was processed by some worker for this execution. +# Will be zero if no task has ever started. + sig { returns(Integer) } + def previous_started_event_id + end + + # The last workflow task started event which was processed by some worker for this execution. +# Will be zero if no task has ever started. + sig { params(value: Integer).void } + def previous_started_event_id=(value) + end + + # The last workflow task started event which was processed by some worker for this execution. +# Will be zero if no task has ever started. + sig { void } + def clear_previous_started_event_id + end + + # The id of the most recent workflow task started event, which will have been generated as a +# result of this poll request being served. Will be zero if the task +# does not contain any events which would advance history (no new WFT started). +# Currently this can happen for queries. + sig { returns(Integer) } + def started_event_id + end + + # The id of the most recent workflow task started event, which will have been generated as a +# result of this poll request being served. Will be zero if the task +# does not contain any events which would advance history (no new WFT started). +# Currently this can happen for queries. + sig { params(value: Integer).void } + def started_event_id=(value) + end + + # The id of the most recent workflow task started event, which will have been generated as a +# result of this poll request being served. Will be zero if the task +# does not contain any events which would advance history (no new WFT started). +# Currently this can happen for queries. + sig { void } + def clear_started_event_id + end + + # Starting at 1, the number of attempts to complete this task by any worker. + sig { returns(Integer) } + def attempt + end + + # Starting at 1, the number of attempts to complete this task by any worker. + sig { params(value: Integer).void } + def attempt=(value) + end + + # Starting at 1, the number of attempts to complete this task by any worker. + sig { void } + def clear_attempt + end + + # A hint that there are more tasks already present in this task queue +# partition. Can be used to prioritize draining a sticky queue. +# +# Specifically, the returned number is the number of tasks remaining in +# the in-memory buffer for this partition, which is currently capped at +# 1000. Because sticky queues only have one partition, this number is +# more useful when draining them. Normal queues, typically having more than one +# partition, will return a number representing only some portion of the +# overall backlog. Subsequent RPCs may not hit the same partition as +# this call. + sig { returns(Integer) } + def backlog_count_hint + end + + # A hint that there are more tasks already present in this task queue +# partition. Can be used to prioritize draining a sticky queue. +# +# Specifically, the returned number is the number of tasks remaining in +# the in-memory buffer for this partition, which is currently capped at +# 1000. Because sticky queues only have one partition, this number is +# more useful when draining them. Normal queues, typically having more than one +# partition, will return a number representing only some portion of the +# overall backlog. Subsequent RPCs may not hit the same partition as +# this call. + sig { params(value: Integer).void } + def backlog_count_hint=(value) + end + + # A hint that there are more tasks already present in this task queue +# partition. Can be used to prioritize draining a sticky queue. +# +# Specifically, the returned number is the number of tasks remaining in +# the in-memory buffer for this partition, which is currently capped at +# 1000. Because sticky queues only have one partition, this number is +# more useful when draining them. Normal queues, typically having more than one +# partition, will return a number representing only some portion of the +# overall backlog. Subsequent RPCs may not hit the same partition as +# this call. + sig { void } + def clear_backlog_count_hint + end + + # The history for this workflow, which will either be complete or partial. Partial histories +# are sent to workers who have signaled that they are using a sticky queue when completing +# a workflow task. + sig { returns(T.nilable(Temporalio::Api::History::V1::History)) } + def history + end + + # The history for this workflow, which will either be complete or partial. Partial histories +# are sent to workers who have signaled that they are using a sticky queue when completing +# a workflow task. + sig { params(value: T.nilable(Temporalio::Api::History::V1::History)).void } + def history=(value) + end + + # The history for this workflow, which will either be complete or partial. Partial histories +# are sent to workers who have signaled that they are using a sticky queue when completing +# a workflow task. + sig { void } + def clear_history + end + + # Will be set if there are more history events than were included in this response. Such events +# should be fetched via `GetWorkflowExecutionHistory`. + sig { returns(String) } + def next_page_token + end + + # Will be set if there are more history events than were included in this response. Such events +# should be fetched via `GetWorkflowExecutionHistory`. + sig { params(value: String).void } + def next_page_token=(value) + end + + # Will be set if there are more history events than were included in this response. Such events +# should be fetched via `GetWorkflowExecutionHistory`. + sig { void } + def clear_next_page_token + end + + # Legacy queries appear in this field. The query must be responded to via +# `RespondQueryTaskCompleted`. If the workflow is already closed (queries are permitted on +# closed workflows) then the `history` field will be populated with the entire history. It +# may also be populated if this task originates on a non-sticky queue. + sig { returns(T.nilable(Temporalio::Api::Query::V1::WorkflowQuery)) } + def query + end + + # Legacy queries appear in this field. The query must be responded to via +# `RespondQueryTaskCompleted`. If the workflow is already closed (queries are permitted on +# closed workflows) then the `history` field will be populated with the entire history. It +# may also be populated if this task originates on a non-sticky queue. + sig { params(value: T.nilable(Temporalio::Api::Query::V1::WorkflowQuery)).void } + def query=(value) + end + + # Legacy queries appear in this field. The query must be responded to via +# `RespondQueryTaskCompleted`. If the workflow is already closed (queries are permitted on +# closed workflows) then the `history` field will be populated with the entire history. It +# may also be populated if this task originates on a non-sticky queue. + sig { void } + def clear_query + end + + # The task queue this task originated from, which will always be the original non-sticky name +# for the queue, even if this response came from polling a sticky queue. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def workflow_execution_task_queue + end + + # The task queue this task originated from, which will always be the original non-sticky name +# for the queue, even if this response came from polling a sticky queue. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def workflow_execution_task_queue=(value) + end + + # The task queue this task originated from, which will always be the original non-sticky name +# for the queue, even if this response came from polling a sticky queue. + sig { void } + def clear_workflow_execution_task_queue + end + + # When this task was scheduled by the server + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def scheduled_time + end + + # When this task was scheduled by the server + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def scheduled_time=(value) + end + + # When this task was scheduled by the server + sig { void } + def clear_scheduled_time + end + + # When the current workflow task started event was generated, meaning the current attempt. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def started_time + end + + # When the current workflow task started event was generated, meaning the current attempt. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def started_time=(value) + end + + # When the current workflow task started event was generated, meaning the current attempt. + sig { void } + def clear_started_time + end + + # Queries that should be executed after applying the history in this task. Responses should be +# attached to `RespondWorkflowTaskCompletedRequest::query_results` + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Query::V1::WorkflowQuery)]) } + def queries + end + + # Queries that should be executed after applying the history in this task. Responses should be +# attached to `RespondWorkflowTaskCompletedRequest::query_results` + sig { params(value: ::Google::Protobuf::Map).void } + def queries=(value) + end + + # Queries that should be executed after applying the history in this task. Responses should be +# attached to `RespondWorkflowTaskCompletedRequest::query_results` + sig { void } + def clear_queries + end + + # Protocol messages piggybacking on a WFT as a transport + sig { returns(T::Array[T.nilable(Temporalio::Api::Protocol::V1::Message)]) } + def messages + end + + # Protocol messages piggybacking on a WFT as a transport + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def messages=(value) + end + + # Protocol messages piggybacking on a WFT as a transport + sig { void } + def clear_messages + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision)) } + def poller_scaling_decision + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision)).void } + def poller_scaling_decision=(value) + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { void } + def clear_poller_scaling_decision + end + + # This poller group ID identifies the owner of the workflow task awaiting for query response. +# Corresponding RespondQueryTaskCompleted should pass this value for proper routing. + sig { returns(String) } + def poller_group_id + end + + # This poller group ID identifies the owner of the workflow task awaiting for query response. +# Corresponding RespondQueryTaskCompleted should pass this value for proper routing. + sig { params(value: String).void } + def poller_group_id=(value) + end + + # This poller group ID identifies the owner of the workflow task awaiting for query response. +# Corresponding RespondQueryTaskCompleted should pass this value for proper routing. + sig { void } + def clear_poller_group_id + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerGroupInfo)]) } + def poller_group_infos + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def poller_group_infos=(value) + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { void } + def clear_poller_group_infos + 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::WorkflowService::V1::PollWorkflowTaskQueueResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse, 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::WorkflowService::V1::RespondWorkflowTaskCompletedRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + commands: T.nilable(T::Array[T.nilable(Temporalio::Api::Command::V1::Command)]), + identity: T.nilable(String), + sticky_attributes: T.nilable(Temporalio::Api::TaskQueue::V1::StickyExecutionAttributes), + return_new_workflow_task: T.nilable(T::Boolean), + force_create_new_workflow_task: T.nilable(T::Boolean), + binary_checksum: T.nilable(String), + query_results: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Query::V1::WorkflowQueryResult)]), + namespace: T.nilable(String), + resource_id: T.nilable(String), + worker_version_stamp: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + messages: T.nilable(T::Array[T.nilable(Temporalio::Api::Protocol::V1::Message)]), + sdk_metadata: T.nilable(Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata), + metering_metadata: T.nilable(Temporalio::Api::Common::V1::MeteringMetadata), + capabilities: T.nilable(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest::Capabilities), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + versioning_behavior: T.nilable(T.any(Symbol, String, Integer)), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions), + worker_instance_key: T.nilable(String), + worker_control_task_queue: T.nilable(String) + ).void + end + def initialize( + task_token: "", + commands: [], + identity: "", + sticky_attributes: nil, + return_new_workflow_task: false, + force_create_new_workflow_task: false, + binary_checksum: "", + query_results: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Query::V1::WorkflowQueryResult), + namespace: "", + resource_id: "", + worker_version_stamp: nil, + messages: [], + sdk_metadata: nil, + metering_metadata: nil, + capabilities: nil, + deployment: nil, + versioning_behavior: :VERSIONING_BEHAVIOR_UNSPECIFIED, + deployment_options: nil, + worker_instance_key: "", + worker_control_task_queue: "" + ) + end + + # The task token as received in `PollWorkflowTaskQueueResponse` + sig { returns(String) } + def task_token + end + + # The task token as received in `PollWorkflowTaskQueueResponse` + sig { params(value: String).void } + def task_token=(value) + end + + # The task token as received in `PollWorkflowTaskQueueResponse` + sig { void } + def clear_task_token + end + + # A list of commands generated when driving the workflow code in response to the new task + sig { returns(T::Array[T.nilable(Temporalio::Api::Command::V1::Command)]) } + def commands + end + + # A list of commands generated when driving the workflow code in response to the new task + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def commands=(value) + end + + # A list of commands generated when driving the workflow code in response to the new task + sig { void } + def clear_commands + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # May be set by workers to indicate that the worker desires future tasks to be provided with +# incremental history on a sticky queue. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::StickyExecutionAttributes)) } + def sticky_attributes + end + + # May be set by workers to indicate that the worker desires future tasks to be provided with +# incremental history on a sticky queue. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::StickyExecutionAttributes)).void } + def sticky_attributes=(value) + end + + # May be set by workers to indicate that the worker desires future tasks to be provided with +# incremental history on a sticky queue. + sig { void } + def clear_sticky_attributes + end + + # If set, the worker wishes to immediately receive the next workflow task as a response to +# this completion. This can save on polling round-trips. + sig { returns(T::Boolean) } + def return_new_workflow_task + end + + # If set, the worker wishes to immediately receive the next workflow task as a response to +# this completion. This can save on polling round-trips. + sig { params(value: T::Boolean).void } + def return_new_workflow_task=(value) + end + + # If set, the worker wishes to immediately receive the next workflow task as a response to +# this completion. This can save on polling round-trips. + sig { void } + def clear_return_new_workflow_task + end + + # Can be used to *force* creation of a new workflow task, even if no commands have resolved or +# one would not otherwise have been generated. This is used when the worker knows it is doing +# something useful, but cannot complete it within the workflow task timeout. Local activities +# which run for longer than the task timeout being the prime example. + sig { returns(T::Boolean) } + def force_create_new_workflow_task + end + + # Can be used to *force* creation of a new workflow task, even if no commands have resolved or +# one would not otherwise have been generated. This is used when the worker knows it is doing +# something useful, but cannot complete it within the workflow task timeout. Local activities +# which run for longer than the task timeout being the prime example. + sig { params(value: T::Boolean).void } + def force_create_new_workflow_task=(value) + end + + # Can be used to *force* creation of a new workflow task, even if no commands have resolved or +# one would not otherwise have been generated. This is used when the worker knows it is doing +# something useful, but cannot complete it within the workflow task timeout. Local activities +# which run for longer than the task timeout being the prime example. + sig { void } + def clear_force_create_new_workflow_task + end + + # Deprecated. Use `deployment_options` instead. +# Worker process' unique binary id + sig { returns(String) } + def binary_checksum + end + + # Deprecated. Use `deployment_options` instead. +# Worker process' unique binary id + sig { params(value: String).void } + def binary_checksum=(value) + end + + # Deprecated. Use `deployment_options` instead. +# Worker process' unique binary id + sig { void } + def clear_binary_checksum + end + + # Responses to the `queries` field in the task being responded to + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Query::V1::WorkflowQueryResult)]) } + def query_results + end + + # Responses to the `queries` field in the task being responded to + sig { params(value: ::Google::Protobuf::Map).void } + def query_results=(value) + end + + # Responses to the `queries` field in the task being responded to + sig { void } + def clear_query_results + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Resource ID for routing. Contains the workflow ID from the original task. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the workflow ID from the original task. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the workflow ID from the original task. + sig { void } + def clear_resource_id + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` and `versioning_behavior` instead. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version_stamp + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` and `versioning_behavior` instead. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version_stamp=(value) + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` and `versioning_behavior` instead. + sig { void } + def clear_worker_version_stamp + end + + # Protocol messages piggybacking on a WFT as a transport + sig { returns(T::Array[T.nilable(Temporalio::Api::Protocol::V1::Message)]) } + def messages + end + + # Protocol messages piggybacking on a WFT as a transport + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def messages=(value) + end + + # Protocol messages piggybacking on a WFT as a transport + sig { void } + def clear_messages + end + + # Data the SDK wishes to record for itself, but server need not interpret, and does not +# directly impact workflow state. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata)) } + def sdk_metadata + end + + # Data the SDK wishes to record for itself, but server need not interpret, and does not +# directly impact workflow state. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::WorkflowTaskCompletedMetadata)).void } + def sdk_metadata=(value) + end + + # Data the SDK wishes to record for itself, but server need not interpret, and does not +# directly impact workflow state. + sig { void } + def clear_sdk_metadata + end + + # Local usage data collected for metering + sig { returns(T.nilable(Temporalio::Api::Common::V1::MeteringMetadata)) } + def metering_metadata + end + + # Local usage data collected for metering + sig { params(value: T.nilable(Temporalio::Api::Common::V1::MeteringMetadata)).void } + def metering_metadata=(value) + end + + # Local usage data collected for metering + sig { void } + def clear_metering_metadata + end + + # All capabilities the SDK supports. + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest::Capabilities)) } + def capabilities + end + + # All capabilities the SDK supports. + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest::Capabilities)).void } + def capabilities=(value) + end + + # All capabilities the SDK supports. + sig { void } + def clear_capabilities + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { void } + def clear_deployment + end + + # Versioning behavior of this workflow execution as set on the worker that completed this task. +# UNSPECIFIED means versioning is not enabled in the worker. + sig { returns(T.any(Symbol, Integer)) } + def versioning_behavior + end + + # Versioning behavior of this workflow execution as set on the worker that completed this task. +# UNSPECIFIED means versioning is not enabled in the worker. + sig { params(value: T.any(Symbol, String, Integer)).void } + def versioning_behavior=(value) + end + + # Versioning behavior of this workflow execution as set on the worker that completed this task. +# UNSPECIFIED means versioning is not enabled in the worker. + sig { void } + def clear_versioning_behavior + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + sig { void } + def clear_deployment_options + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { returns(String) } + def worker_instance_key + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { void } + def clear_worker_instance_key + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { returns(String) } + def worker_control_task_queue + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { params(value: String).void } + def worker_control_task_queue=(value) + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { void } + def clear_worker_control_task_queue + 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::WorkflowService::V1::RespondWorkflowTaskCompletedRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest, 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::WorkflowService::V1::RespondWorkflowTaskCompletedResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_task: T.nilable(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse), + activity_tasks: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueResponse)]), + reset_history_event_id: T.nilable(Integer) + ).void + end + def initialize( + workflow_task: nil, + activity_tasks: [], + reset_history_event_id: 0 + ) + end + + # See `RespondWorkflowTaskCompletedResponse::return_new_workflow_task` + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse)) } + def workflow_task + end + + # See `RespondWorkflowTaskCompletedResponse::return_new_workflow_task` + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse)).void } + def workflow_task=(value) + end + + # See `RespondWorkflowTaskCompletedResponse::return_new_workflow_task` + sig { void } + def clear_workflow_task + end + + # See `ScheduleActivityTaskCommandAttributes::request_eager_execution` + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueResponse)]) } + def activity_tasks + end + + # See `ScheduleActivityTaskCommandAttributes::request_eager_execution` + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def activity_tasks=(value) + end + + # See `ScheduleActivityTaskCommandAttributes::request_eager_execution` + sig { void } + def clear_activity_tasks + end + + # If non zero, indicates the server has discarded the workflow task that was being responded to. +# Will be the event ID of the last workflow task started event in the history before the new workflow task. +# Server is only expected to discard a workflow task if it could not have modified the workflow state. + sig { returns(Integer) } + def reset_history_event_id + end + + # If non zero, indicates the server has discarded the workflow task that was being responded to. +# Will be the event ID of the last workflow task started event in the history before the new workflow task. +# Server is only expected to discard a workflow task if it could not have modified the workflow state. + sig { params(value: Integer).void } + def reset_history_event_id=(value) + end + + # If non zero, indicates the server has discarded the workflow task that was being responded to. +# Will be the event ID of the last workflow task started event in the history before the new workflow task. +# Server is only expected to discard a workflow task if it could not have modified the workflow state. + sig { void } + def clear_reset_history_event_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::WorkflowService::V1::RespondWorkflowTaskCompletedResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedResponse, 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::WorkflowService::V1::RespondWorkflowTaskFailedRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + cause: T.nilable(T.any(Symbol, String, Integer)), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + identity: T.nilable(String), + binary_checksum: T.nilable(String), + namespace: T.nilable(String), + resource_id: T.nilable(String), + messages: T.nilable(T::Array[T.nilable(Temporalio::Api::Protocol::V1::Message)]), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions) + ).void + end + def initialize( + task_token: "", + cause: :WORKFLOW_TASK_FAILED_CAUSE_UNSPECIFIED, + failure: nil, + identity: "", + binary_checksum: "", + namespace: "", + resource_id: "", + messages: [], + worker_version: nil, + deployment: nil, + deployment_options: nil + ) + end + + # The task token as received in `PollWorkflowTaskQueueResponse` + sig { returns(String) } + def task_token + end + + # The task token as received in `PollWorkflowTaskQueueResponse` + sig { params(value: String).void } + def task_token=(value) + end + + # The task token as received in `PollWorkflowTaskQueueResponse` + sig { void } + def clear_task_token + end + + # Why did the task fail? It's important to note that many of the variants in this enum cannot +# apply to worker responses. See the type's doc for more. + sig { returns(T.any(Symbol, Integer)) } + def cause + end + + # Why did the task fail? It's important to note that many of the variants in this enum cannot +# apply to worker responses. See the type's doc for more. + sig { params(value: T.any(Symbol, String, Integer)).void } + def cause=(value) + end + + # Why did the task fail? It's important to note that many of the variants in this enum cannot +# apply to worker responses. See the type's doc for more. + sig { void } + def clear_cause + end + + # Failure details + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Failure details + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Failure details + sig { void } + def clear_failure + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # Deprecated. Use `deployment_options` instead. +# Worker process' unique binary id + sig { returns(String) } + def binary_checksum + end + + # Deprecated. Use `deployment_options` instead. +# Worker process' unique binary id + sig { params(value: String).void } + def binary_checksum=(value) + end + + # Deprecated. Use `deployment_options` instead. +# Worker process' unique binary id + sig { void } + def clear_binary_checksum + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Resource ID for routing. Contains the workflow ID from the original task. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the workflow ID from the original task. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the workflow ID from the original task. + sig { void } + def clear_resource_id + end + + # Protocol messages piggybacking on a WFT as a transport + sig { returns(T::Array[T.nilable(Temporalio::Api::Protocol::V1::Message)]) } + def messages + end + + # Protocol messages piggybacking on a WFT as a transport + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def messages=(value) + end + + # Protocol messages piggybacking on a WFT as a transport + sig { void } + def clear_messages + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { void } + def clear_worker_version + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { void } + def clear_deployment + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + 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::WorkflowService::V1::RespondWorkflowTaskFailedRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskFailedRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskFailedRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskFailedRequest, 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::WorkflowService::V1::RespondWorkflowTaskFailedResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RespondWorkflowTaskFailedResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskFailedResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskFailedResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskFailedResponse, 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::WorkflowService::V1::PollActivityTaskQueueRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + poller_group_id: T.nilable(String), + identity: T.nilable(String), + worker_instance_key: T.nilable(String), + worker_control_task_queue: T.nilable(String), + task_queue_metadata: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueMetadata), + worker_version_capabilities: T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions) + ).void + end + def initialize( + namespace: "", + task_queue: nil, + poller_group_id: "", + identity: "", + worker_instance_key: "", + worker_control_task_queue: "", + task_queue_metadata: nil, + worker_version_capabilities: nil, + deployment_options: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollActivityTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { returns(String) } + def poller_group_id + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollActivityTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { params(value: String).void } + def poller_group_id=(value) + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollActivityTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { void } + def clear_poller_group_id + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { returns(String) } + def worker_instance_key + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { void } + def clear_worker_instance_key + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { returns(String) } + def worker_control_task_queue + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { params(value: String).void } + def worker_control_task_queue=(value) + end + + # A dedicated per-worker Nexus task queue on which the server sends control +# tasks (e.g. activity cancellation) to this specific worker instance. + sig { void } + def clear_worker_control_task_queue + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueMetadata)) } + def task_queue_metadata + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueMetadata)).void } + def task_queue_metadata=(value) + end + + sig { void } + def clear_task_queue_metadata + end + + # Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. +# Deprecated. Replaced by deployment_options. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities)) } + def worker_version_capabilities + end + + # Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. +# Deprecated. Replaced by deployment_options. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities)).void } + def worker_version_capabilities=(value) + end + + # Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. +# Deprecated. Replaced by deployment_options. + sig { void } + def clear_worker_version_capabilities + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + 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::WorkflowService::V1::PollActivityTaskQueueRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueRequest, 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::WorkflowService::V1::PollActivityTaskQueueResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + workflow_namespace: T.nilable(String), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + activity_type: T.nilable(Temporalio::Api::Common::V1::ActivityType), + activity_id: T.nilable(String), + header: T.nilable(Temporalio::Api::Common::V1::Header), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + heartbeat_details: T.nilable(Temporalio::Api::Common::V1::Payloads), + scheduled_time: T.nilable(Google::Protobuf::Timestamp), + current_attempt_scheduled_time: T.nilable(Google::Protobuf::Timestamp), + started_time: T.nilable(Google::Protobuf::Timestamp), + attempt: T.nilable(Integer), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + heartbeat_timeout: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + poller_scaling_decision: T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + activity_run_id: T.nilable(String), + poller_group_infos: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerGroupInfo)]) + ).void + end + def initialize( + task_token: "", + workflow_namespace: "", + workflow_type: nil, + workflow_execution: nil, + activity_type: nil, + activity_id: "", + header: nil, + input: nil, + heartbeat_details: nil, + scheduled_time: nil, + current_attempt_scheduled_time: nil, + started_time: nil, + attempt: 0, + schedule_to_close_timeout: nil, + start_to_close_timeout: nil, + heartbeat_timeout: nil, + retry_policy: nil, + poller_scaling_decision: nil, + priority: nil, + activity_run_id: "", + poller_group_infos: [] + ) + end + + # A unique identifier for this task + sig { returns(String) } + def task_token + end + + # A unique identifier for this task + sig { params(value: String).void } + def task_token=(value) + end + + # A unique identifier for this task + sig { void } + def clear_task_token + end + + # The namespace of the activity. If this is a workflow activity then this is the namespace of +# the workflow also. If this is a standalone activity then the name of this field is +# misleading, but retained for compatibility with workflow activities. + sig { returns(String) } + def workflow_namespace + end + + # The namespace of the activity. If this is a workflow activity then this is the namespace of +# the workflow also. If this is a standalone activity then the name of this field is +# misleading, but retained for compatibility with workflow activities. + sig { params(value: String).void } + def workflow_namespace=(value) + end + + # The namespace of the activity. If this is a workflow activity then this is the namespace of +# the workflow also. If this is a standalone activity then the name of this field is +# misleading, but retained for compatibility with workflow activities. + sig { void } + def clear_workflow_namespace + end + + # Type of the requesting workflow (if this is a workflow activity). + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + # Type of the requesting workflow (if this is a workflow activity). + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + # Type of the requesting workflow (if this is a workflow activity). + sig { void } + def clear_workflow_type + end + + # Execution info of the requesting workflow (if this is a workflow activity) + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + # Execution info of the requesting workflow (if this is a workflow activity) + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + # Execution info of the requesting workflow (if this is a workflow activity) + sig { void } + def clear_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::ActivityType)) } + def activity_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ActivityType)).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + end + + # The autogenerated or user specified identifier of this activity. Can be used to complete the +# activity via `RespondActivityTaskCompletedById`. May be re-used as long as the last usage +# has resolved, but unique IDs for every activity invocation is a good idea. +# Note that only a workflow activity ID may be autogenerated. + sig { returns(String) } + def activity_id + end + + # The autogenerated or user specified identifier of this activity. Can be used to complete the +# activity via `RespondActivityTaskCompletedById`. May be re-used as long as the last usage +# has resolved, but unique IDs for every activity invocation is a good idea. +# Note that only a workflow activity ID may be autogenerated. + sig { params(value: String).void } + def activity_id=(value) + end + + # The autogenerated or user specified identifier of this activity. Can be used to complete the +# activity via `RespondActivityTaskCompletedById`. May be re-used as long as the last usage +# has resolved, but unique IDs for every activity invocation is a good idea. +# Note that only a workflow activity ID may be autogenerated. + sig { void } + def clear_activity_id + end + + # Headers specified by the scheduling workflow. Commonly used to propagate contextual info +# from the workflow to its activities. For example, tracing contexts. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Headers specified by the scheduling workflow. Commonly used to propagate contextual info +# from the workflow to its activities. For example, tracing contexts. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Headers specified by the scheduling workflow. Commonly used to propagate contextual info +# from the workflow to its activities. For example, tracing contexts. + sig { void } + def clear_header + end + + # Arguments to the activity invocation + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Arguments to the activity invocation + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Arguments to the activity invocation + sig { void } + def clear_input + end + + # Details of the last heartbeat that was recorded for this activity as of the time this task +# was delivered. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def heartbeat_details + end + + # Details of the last heartbeat that was recorded for this activity as of the time this task +# was delivered. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def heartbeat_details=(value) + end + + # Details of the last heartbeat that was recorded for this activity as of the time this task +# was delivered. + sig { void } + def clear_heartbeat_details + end + + # When was this task first scheduled + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def scheduled_time + end + + # When was this task first scheduled + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def scheduled_time=(value) + end + + # When was this task first scheduled + sig { void } + def clear_scheduled_time + end + + # When was this task attempt scheduled + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def current_attempt_scheduled_time + end + + # When was this task attempt scheduled + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def current_attempt_scheduled_time=(value) + end + + # When was this task attempt scheduled + sig { void } + def clear_current_attempt_scheduled_time + end + + # When was this task started (this attempt) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def started_time + end + + # When was this task started (this attempt) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def started_time=(value) + end + + # When was this task started (this attempt) + sig { void } + def clear_started_time + end + + # Starting at 1, the number of attempts to perform this activity + sig { returns(Integer) } + def attempt + end + + # Starting at 1, the number of attempts to perform this activity + sig { params(value: Integer).void } + def attempt=(value) + end + + # Starting at 1, the number of attempts to perform this activity + sig { void } + def clear_attempt + end + + # First scheduled -> final result reported timeout +# +# (-- 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_close_timeout + end + + # First scheduled -> final result reported timeout +# +# (-- 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_close_timeout=(value) + end + + # First scheduled -> final result reported timeout +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Current attempt start -> final result reported timeout +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Current attempt start -> final result reported timeout +# +# (-- 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 start_to_close_timeout=(value) + end + + # Current attempt start -> final result reported timeout +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # Window within which the activity must report a heartbeat, or be timed out. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def heartbeat_timeout + end + + # Window within which the activity must report a heartbeat, or be timed out. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def heartbeat_timeout=(value) + end + + # Window within which the activity must report a heartbeat, or be timed out. + sig { void } + def clear_heartbeat_timeout + end + + # This is the retry policy the service uses which may be different from the one provided +# (or not) during activity scheduling. The service can override the provided one if some +# values are not specified or exceed configured system limits. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # This is the retry policy the service uses which may be different from the one provided +# (or not) during activity scheduling. The service can override the provided one if some +# values are not specified or exceed configured system limits. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # This is the retry policy the service uses which may be different from the one provided +# (or not) during activity scheduling. The service can override the provided one if some +# values are not specified or exceed configured system limits. + sig { void } + def clear_retry_policy + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision)) } + def poller_scaling_decision + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision)).void } + def poller_scaling_decision=(value) + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { void } + def clear_poller_scaling_decision + end + + # Priority metadata + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata + sig { void } + def clear_priority + end + + # The run ID of the activity execution, only set for standalone activities. + sig { returns(String) } + def activity_run_id + end + + # The run ID of the activity execution, only set for standalone activities. + sig { params(value: String).void } + def activity_run_id=(value) + end + + # The run ID of the activity execution, only set for standalone activities. + sig { void } + def clear_activity_run_id + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerGroupInfo)]) } + def poller_group_infos + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def poller_group_infos=(value) + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { void } + def clear_poller_group_infos + 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::WorkflowService::V1::PollActivityTaskQueueResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueResponse, 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::WorkflowService::V1::RecordActivityTaskHeartbeatRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + namespace: T.nilable(String), + resource_id: T.nilable(String) + ).void + end + def initialize( + task_token: "", + details: nil, + identity: "", + namespace: "", + resource_id: "" + ) + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { returns(String) } + def task_token + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { params(value: String).void } + def task_token=(value) + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { void } + def clear_task_token + end + + # Arbitrary data, of which the most recent call is kept, to store for this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + # Arbitrary data, of which the most recent call is kept, to store for this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + # Arbitrary data, of which the most recent call is kept, to store for this activity + sig { void } + def clear_details + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { void } + def clear_resource_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::WorkflowService::V1::RecordActivityTaskHeartbeatRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatRequest, 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::WorkflowService::V1::RecordActivityTaskHeartbeatResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cancel_requested: T.nilable(T::Boolean), + activity_paused: T.nilable(T::Boolean), + activity_reset: T.nilable(T::Boolean) + ).void + end + def initialize( + cancel_requested: false, + activity_paused: false, + activity_reset: false + ) + end + + # Will be set to true if the activity has been asked to cancel itself. The SDK should then +# notify the activity of cancellation if it is still running. + sig { returns(T::Boolean) } + def cancel_requested + end + + # Will be set to true if the activity has been asked to cancel itself. The SDK should then +# notify the activity of cancellation if it is still running. + sig { params(value: T::Boolean).void } + def cancel_requested=(value) + end + + # Will be set to true if the activity has been asked to cancel itself. The SDK should then +# notify the activity of cancellation if it is still running. + sig { void } + def clear_cancel_requested + end + + # Will be set to true if the activity is paused. + sig { returns(T::Boolean) } + def activity_paused + end + + # Will be set to true if the activity is paused. + sig { params(value: T::Boolean).void } + def activity_paused=(value) + end + + # Will be set to true if the activity is paused. + sig { void } + def clear_activity_paused + end + + # Will be set to true if the activity was reset. +# Applies only to the current run. + sig { returns(T::Boolean) } + def activity_reset + end + + # Will be set to true if the activity was reset. +# Applies only to the current run. + sig { params(value: T::Boolean).void } + def activity_reset=(value) + end + + # Will be set to true if the activity was reset. +# Applies only to the current run. + sig { void } + def clear_activity_reset + 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::WorkflowService::V1::RecordActivityTaskHeartbeatResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatResponse, 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::WorkflowService::V1::RecordActivityTaskHeartbeatByIdRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String), + activity_id: T.nilable(String), + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + resource_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "", + activity_id: "", + details: nil, + identity: "", + resource_id: "" + ) + end + + # Namespace of the workflow which scheduled this activity + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which scheduled this activity + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which scheduled this activity + sig { void } + def clear_namespace + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { returns(String) } + def workflow_id + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { params(value: String).void } + def workflow_id=(value) + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { void } + def clear_workflow_id + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { returns(String) } + def run_id + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { params(value: String).void } + def run_id=(value) + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { void } + def clear_run_id + end + + # Id of the activity we're heartbeating + sig { returns(String) } + def activity_id + end + + # Id of the activity we're heartbeating + sig { params(value: String).void } + def activity_id=(value) + end + + # Id of the activity we're heartbeating + sig { void } + def clear_activity_id + end + + # Arbitrary data, of which the most recent call is kept, to store for this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + # Arbitrary data, of which the most recent call is kept, to store for this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + # Arbitrary data, of which the most recent call is kept, to store for this activity + sig { void } + def clear_details + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { void } + def clear_resource_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::WorkflowService::V1::RecordActivityTaskHeartbeatByIdRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdRequest, 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::WorkflowService::V1::RecordActivityTaskHeartbeatByIdResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + cancel_requested: T.nilable(T::Boolean), + activity_paused: T.nilable(T::Boolean), + activity_reset: T.nilable(T::Boolean) + ).void + end + def initialize( + cancel_requested: false, + activity_paused: false, + activity_reset: false + ) + end + + # Will be set to true if the activity has been asked to cancel itself. The SDK should then +# notify the activity of cancellation if it is still running. + sig { returns(T::Boolean) } + def cancel_requested + end + + # Will be set to true if the activity has been asked to cancel itself. The SDK should then +# notify the activity of cancellation if it is still running. + sig { params(value: T::Boolean).void } + def cancel_requested=(value) + end + + # Will be set to true if the activity has been asked to cancel itself. The SDK should then +# notify the activity of cancellation if it is still running. + sig { void } + def clear_cancel_requested + end + + # Will be set to true if the activity is paused. + sig { returns(T::Boolean) } + def activity_paused + end + + # Will be set to true if the activity is paused. + sig { params(value: T::Boolean).void } + def activity_paused=(value) + end + + # Will be set to true if the activity is paused. + sig { void } + def clear_activity_paused + end + + # Will be set to true if the activity was reset. +# Applies only to the current run. + sig { returns(T::Boolean) } + def activity_reset + end + + # Will be set to true if the activity was reset. +# Applies only to the current run. + sig { params(value: T::Boolean).void } + def activity_reset=(value) + end + + # Will be set to true if the activity was reset. +# Applies only to the current run. + sig { void } + def clear_activity_reset + 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::WorkflowService::V1::RecordActivityTaskHeartbeatByIdResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdResponse, 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::WorkflowService::V1::RespondActivityTaskCompletedRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + result: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + namespace: T.nilable(String), + resource_id: T.nilable(String), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions) + ).void + end + def initialize( + task_token: "", + result: nil, + identity: "", + namespace: "", + resource_id: "", + worker_version: nil, + deployment: nil, + deployment_options: nil + ) + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { returns(String) } + def task_token + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { params(value: String).void } + def task_token=(value) + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { void } + def clear_task_token + end + + # The result of successfully executing the activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def result + end + + # The result of successfully executing the activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def result=(value) + end + + # The result of successfully executing the activity + sig { void } + def clear_result + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { void } + def clear_resource_id + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { void } + def clear_worker_version + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { void } + def clear_deployment + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + 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::WorkflowService::V1::RespondActivityTaskCompletedRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedRequest, 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::WorkflowService::V1::RespondActivityTaskCompletedResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RespondActivityTaskCompletedResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedResponse, 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::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String), + activity_id: T.nilable(String), + result: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + resource_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "", + activity_id: "", + result: nil, + identity: "", + resource_id: "" + ) + end + + # Namespace of the workflow which scheduled this activity + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which scheduled this activity + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which scheduled this activity + sig { void } + def clear_namespace + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { returns(String) } + def workflow_id + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { params(value: String).void } + def workflow_id=(value) + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { void } + def clear_workflow_id + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { returns(String) } + def run_id + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { params(value: String).void } + def run_id=(value) + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { void } + def clear_run_id + end + + # Id of the activity to complete + sig { returns(String) } + def activity_id + end + + # Id of the activity to complete + sig { params(value: String).void } + def activity_id=(value) + end + + # Id of the activity to complete + sig { void } + def clear_activity_id + end + + # The serialized result of activity execution + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def result + end + + # The serialized result of activity execution + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def result=(value) + end + + # The serialized result of activity execution + sig { void } + def clear_result + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { void } + def clear_resource_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::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest, 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::WorkflowService::V1::RespondActivityTaskCompletedByIdResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RespondActivityTaskCompletedByIdResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdResponse, 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::WorkflowService::V1::RespondActivityTaskFailedRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + identity: T.nilable(String), + namespace: T.nilable(String), + resource_id: T.nilable(String), + last_heartbeat_details: T.nilable(Temporalio::Api::Common::V1::Payloads), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions) + ).void + end + def initialize( + task_token: "", + failure: nil, + identity: "", + namespace: "", + resource_id: "", + last_heartbeat_details: nil, + worker_version: nil, + deployment: nil, + deployment_options: nil + ) + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { returns(String) } + def task_token + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { params(value: String).void } + def task_token=(value) + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { void } + def clear_task_token + end + + # Detailed failure information + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Detailed failure information + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Detailed failure information + sig { void } + def clear_failure + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { void } + def clear_resource_id + end + + # Additional details to be stored as last activity heartbeat + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_heartbeat_details + end + + # Additional details to be stored as last activity heartbeat + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_heartbeat_details=(value) + end + + # Additional details to be stored as last activity heartbeat + sig { void } + def clear_last_heartbeat_details + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { void } + def clear_worker_version + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { void } + def clear_deployment + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + 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::WorkflowService::V1::RespondActivityTaskFailedRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedRequest, 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::WorkflowService::V1::RespondActivityTaskFailedResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failures: T.nilable(T::Array[T.nilable(Temporalio::Api::Failure::V1::Failure)]) + ).void + end + def initialize( + failures: [] + ) + end + + # Server validation failures could include +# last_heartbeat_details payload is too large, request failure is too large + sig { returns(T::Array[T.nilable(Temporalio::Api::Failure::V1::Failure)]) } + def failures + end + + # Server validation failures could include +# last_heartbeat_details payload is too large, request failure is too large + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def failures=(value) + end + + # Server validation failures could include +# last_heartbeat_details payload is too large, request failure is too large + sig { void } + def clear_failures + 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::WorkflowService::V1::RespondActivityTaskFailedResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedResponse, 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::WorkflowService::V1::RespondActivityTaskFailedByIdRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String), + activity_id: T.nilable(String), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + identity: T.nilable(String), + last_heartbeat_details: T.nilable(Temporalio::Api::Common::V1::Payloads), + resource_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "", + activity_id: "", + failure: nil, + identity: "", + last_heartbeat_details: nil, + resource_id: "" + ) + end + + # Namespace of the workflow which scheduled this activity + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which scheduled this activity + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which scheduled this activity + sig { void } + def clear_namespace + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { returns(String) } + def workflow_id + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { params(value: String).void } + def workflow_id=(value) + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { void } + def clear_workflow_id + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { returns(String) } + def run_id + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { params(value: String).void } + def run_id=(value) + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { void } + def clear_run_id + end + + # Id of the activity to fail + sig { returns(String) } + def activity_id + end + + # Id of the activity to fail + sig { params(value: String).void } + def activity_id=(value) + end + + # Id of the activity to fail + sig { void } + def clear_activity_id + end + + # Detailed failure information + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # Detailed failure information + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # Detailed failure information + sig { void } + def clear_failure + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # Additional details to be stored as last activity heartbeat + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_heartbeat_details + end + + # Additional details to be stored as last activity heartbeat + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_heartbeat_details=(value) + end + + # Additional details to be stored as last activity heartbeat + sig { void } + def clear_last_heartbeat_details + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { void } + def clear_resource_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::WorkflowService::V1::RespondActivityTaskFailedByIdRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedByIdRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedByIdRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedByIdRequest, 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::WorkflowService::V1::RespondActivityTaskFailedByIdResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failures: T.nilable(T::Array[T.nilable(Temporalio::Api::Failure::V1::Failure)]) + ).void + end + def initialize( + failures: [] + ) + end + + # Server validation failures could include +# last_heartbeat_details payload is too large, request failure is too large + sig { returns(T::Array[T.nilable(Temporalio::Api::Failure::V1::Failure)]) } + def failures + end + + # Server validation failures could include +# last_heartbeat_details payload is too large, request failure is too large + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def failures=(value) + end + + # Server validation failures could include +# last_heartbeat_details payload is too large, request failure is too large + sig { void } + def clear_failures + 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::WorkflowService::V1::RespondActivityTaskFailedByIdResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedByIdResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedByIdResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedByIdResponse, 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::WorkflowService::V1::RespondActivityTaskCanceledRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + namespace: T.nilable(String), + resource_id: T.nilable(String), + worker_version: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions) + ).void + end + def initialize( + task_token: "", + details: nil, + identity: "", + namespace: "", + resource_id: "", + worker_version: nil, + deployment: nil, + deployment_options: nil + ) + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { returns(String) } + def task_token + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { params(value: String).void } + def task_token=(value) + end + + # The task token as received in `PollActivityTaskQueueResponse` + sig { void } + def clear_task_token + end + + # Serialized additional information to attach to the cancellation + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + # Serialized additional information to attach to the cancellation + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + # Serialized additional information to attach to the cancellation + sig { void } + def clear_details + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the workflow ID or activity ID for standalone activities. + sig { void } + def clear_resource_id + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)) } + def worker_version + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionStamp)).void } + def worker_version=(value) + end + + # Version info of the worker who processed this task. This message's `build_id` field should +# always be set by SDKs. Workers opting into versioning will also set the `use_versioning` +# field to true. See message docstrings for more. +# Deprecated. Use `deployment_options` instead. + sig { void } + def clear_worker_version + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + # Deployment info of the worker that completed this task. Must be present if user has set +# `WorkerDeploymentOptions` regardless of versioning being enabled or not. +# Deprecated. Replaced with `deployment_options`. + sig { void } + def clear_deployment + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + 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::WorkflowService::V1::RespondActivityTaskCanceledRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledRequest, 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::WorkflowService::V1::RespondActivityTaskCanceledResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RespondActivityTaskCanceledResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledResponse, 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::WorkflowService::V1::RespondActivityTaskCanceledByIdRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String), + activity_id: T.nilable(String), + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions), + resource_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "", + activity_id: "", + details: nil, + identity: "", + deployment_options: nil, + resource_id: "" + ) + end + + # Namespace of the workflow which scheduled this activity + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which scheduled this activity + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which scheduled this activity + sig { void } + def clear_namespace + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { returns(String) } + def workflow_id + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { params(value: String).void } + def workflow_id=(value) + end + + # Id of the workflow which scheduled this activity, leave empty to target a standalone activity + sig { void } + def clear_workflow_id + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { returns(String) } + def run_id + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { params(value: String).void } + def run_id=(value) + end + + # For a workflow activity - the run ID of the workflow which scheduled this activity. +# For a standalone activity - the run ID of the activity. + sig { void } + def clear_run_id + end + + # Id of the activity to confirm is cancelled + sig { returns(String) } + def activity_id + end + + # Id of the activity to confirm is cancelled + sig { params(value: String).void } + def activity_id=(value) + end + + # Id of the activity to confirm is cancelled + sig { void } + def clear_activity_id + end + + # Serialized additional information to attach to the cancellation + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + # Serialized additional information to attach to the cancellation + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + # Serialized additional information to attach to the cancellation + sig { void } + def clear_details + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + sig { void } + def clear_deployment_options + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains "workflow:workflow_id" or "activity:activity_id" for standalone activities. + sig { void } + def clear_resource_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::WorkflowService::V1::RespondActivityTaskCanceledByIdRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledByIdRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledByIdRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledByIdRequest, 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::WorkflowService::V1::RespondActivityTaskCanceledByIdResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RespondActivityTaskCanceledByIdResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledByIdResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledByIdResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledByIdResponse, 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::WorkflowService::V1::RequestCancelWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + identity: T.nilable(String), + request_id: T.nilable(String), + first_execution_run_id: T.nilable(String), + reason: T.nilable(String), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) + ).void + end + def initialize( + namespace: "", + workflow_execution: nil, + identity: "", + request_id: "", + first_execution_run_id: "", + reason: "", + links: [] + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # Used to de-dupe cancellation requests + sig { returns(String) } + def request_id + end + + # Used to de-dupe cancellation requests + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe cancellation requests + sig { void } + def clear_request_id + end + + # If set, this call will error if the most recent (if no run id is set on +# `workflow_execution`), or specified (if it is) workflow execution is not part of the same +# execution chain as this id. + sig { returns(String) } + def first_execution_run_id + end + + # If set, this call will error if the most recent (if no run id is set on +# `workflow_execution`), or specified (if it is) workflow execution is not part of the same +# execution chain as this id. + sig { params(value: String).void } + def first_execution_run_id=(value) + end + + # If set, this call will error if the most recent (if no run id is set on +# `workflow_execution`), or specified (if it is) workflow execution is not part of the same +# execution chain as this id. + sig { void } + def clear_first_execution_run_id + end + + # Reason for requesting the cancellation + sig { returns(String) } + def reason + end + + # Reason for requesting the cancellation + sig { params(value: String).void } + def reason=(value) + end + + # Reason for requesting the cancellation + sig { void } + def clear_reason + end + + # Links to be associated with the WorkflowExecutionCanceled event. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to be associated with the WorkflowExecutionCanceled event. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to be associated with the WorkflowExecutionCanceled event. + sig { void } + def clear_links + 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::WorkflowService::V1::RequestCancelWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionRequest, 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::WorkflowService::V1::RequestCancelWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RequestCancelWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Keep the parameters in sync with: +# - temporal.api.batch.v1.BatchOperationSignal. +# - temporal.api.workflow.v1.PostResetOperation.SignalWorkflow. +class Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + signal_name: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + request_id: T.nilable(String), + control: T.nilable(String), + header: T.nilable(Temporalio::Api::Common::V1::Header), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) + ).void + end + def initialize( + namespace: "", + workflow_execution: nil, + signal_name: "", + input: nil, + identity: "", + request_id: "", + control: "", + header: nil, + links: [] + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + # The workflow author-defined name of the signal to send to the workflow + sig { returns(String) } + def signal_name + end + + # The workflow author-defined name of the signal to send to the workflow + sig { params(value: String).void } + def signal_name=(value) + end + + # The workflow author-defined name of the signal to send to the workflow + sig { void } + def clear_signal_name + end + + # Serialized value(s) to provide with the signal + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized value(s) to provide with the signal + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized value(s) to provide with the signal + sig { void } + def clear_input + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # Used to de-dupe sent signals + sig { returns(String) } + def request_id + end + + # Used to de-dupe sent signals + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe sent signals + sig { void } + def clear_request_id + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + end + + # Headers that are passed with the signal to the processing workflow. +# These can include things like auth or tracing tokens. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Headers that are passed with the signal to the processing workflow. +# These can include things like auth or tracing tokens. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Headers that are passed with the signal to the processing workflow. +# These can include things like auth or tracing tokens. + sig { void } + def clear_header + end + + # Links to be associated with the WorkflowExecutionSignaled event. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to be associated with the WorkflowExecutionSignaled event. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to be associated with the WorkflowExecutionSignaled event. + sig { void } + def clear_links + 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::WorkflowService::V1::SignalWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionRequest, 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::WorkflowService::V1::SignalWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + link: T.nilable(Temporalio::Api::Common::V1::Link) + ).void + end + def initialize( + link: nil + ) + end + + # Link to be associated with the WorkflowExecutionSignaled event. +# Added on the response to propagate the backlink. +# Available from Temporal server 1.31 and up. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link)) } + def link + end + + # Link to be associated with the WorkflowExecutionSignaled event. +# Added on the response to propagate the backlink. +# Available from Temporal server 1.31 and up. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link)).void } + def link=(value) + end + + # Link to be associated with the WorkflowExecutionSignaled event. +# Added on the response to propagate the backlink. +# Available from Temporal server 1.31 and up. + sig { void } + def clear_link + 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::WorkflowService::V1::SignalWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionResponse, 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::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + workflow_type: T.nilable(Temporalio::Api::Common::V1::WorkflowType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + identity: T.nilable(String), + request_id: T.nilable(String), + workflow_id_reuse_policy: T.nilable(T.any(Symbol, String, Integer)), + workflow_id_conflict_policy: T.nilable(T.any(Symbol, String, Integer)), + signal_name: T.nilable(String), + signal_input: T.nilable(Temporalio::Api::Common::V1::Payloads), + control: T.nilable(String), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + header: T.nilable(Temporalio::Api::Common::V1::Header), + workflow_start_delay: T.nilable(Google::Protobuf::Duration), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]), + versioning_override: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + time_skipping_config: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + workflow_type: nil, + task_queue: nil, + input: nil, + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + identity: "", + request_id: "", + workflow_id_reuse_policy: :WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED, + workflow_id_conflict_policy: :WORKFLOW_ID_CONFLICT_POLICY_UNSPECIFIED, + signal_name: "", + signal_input: nil, + control: "", + retry_policy: nil, + cron_schedule: "", + memo: nil, + search_attributes: nil, + header: nil, + workflow_start_delay: nil, + user_metadata: nil, + links: [], + versioning_override: nil, + priority: nil, + time_skipping_config: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowType)) } + def workflow_type + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowType)).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + # The task queue to start this workflow on, if it will be started + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + # The task queue to start this workflow on, if it will be started + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + # The task queue to start this workflow on, if it will be started + sig { void } + def clear_task_queue + end + + # Serialized arguments to the workflow. These are passed as arguments to the workflow function. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized arguments to the workflow. These are passed as arguments to the workflow function. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized arguments to the workflow. These are passed as arguments to the workflow function. + sig { void } + def clear_input + end + + # Total workflow execution timeout including retries and continue as new + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + # Total workflow execution timeout including retries and continue as new + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + # Total workflow execution timeout including retries and continue as new + sig { void } + def clear_workflow_execution_timeout + end + + # Timeout of a single workflow run + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task + sig { void } + def clear_workflow_task_timeout + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # Used to de-dupe signal w/ start requests + sig { returns(String) } + def request_id + end + + # Used to de-dupe signal w/ start requests + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe signal w/ start requests + sig { void } + def clear_request_id + end + + # Defines whether to allow re-using the workflow id from a previously *closed* workflow. +# The default policy is WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *running* workflow. + sig { returns(T.any(Symbol, Integer)) } + def workflow_id_reuse_policy + end + + # Defines whether to allow re-using the workflow id from a previously *closed* workflow. +# The default policy is WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *running* workflow. + sig { params(value: T.any(Symbol, String, Integer)).void } + def workflow_id_reuse_policy=(value) + end + + # Defines whether to allow re-using the workflow id from a previously *closed* workflow. +# The default policy is WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *running* workflow. + sig { void } + def clear_workflow_id_reuse_policy + end + + # Defines how to resolve a workflow id conflict with a *running* workflow. +# The default policy is WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING. +# Note that WORKFLOW_ID_CONFLICT_POLICY_FAIL is an invalid option. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *closed* workflow. + sig { returns(T.any(Symbol, Integer)) } + def workflow_id_conflict_policy + end + + # Defines how to resolve a workflow id conflict with a *running* workflow. +# The default policy is WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING. +# Note that WORKFLOW_ID_CONFLICT_POLICY_FAIL is an invalid option. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *closed* workflow. + sig { params(value: T.any(Symbol, String, Integer)).void } + def workflow_id_conflict_policy=(value) + end + + # Defines how to resolve a workflow id conflict with a *running* workflow. +# The default policy is WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING. +# Note that WORKFLOW_ID_CONFLICT_POLICY_FAIL is an invalid option. +# +# See `workflow_id_reuse_policy` for handling a workflow id duplication with a *closed* workflow. + sig { void } + def clear_workflow_id_conflict_policy + end + + # The workflow author-defined name of the signal to send to the workflow + sig { returns(String) } + def signal_name + end + + # The workflow author-defined name of the signal to send to the workflow + sig { params(value: String).void } + def signal_name=(value) + end + + # The workflow author-defined name of the signal to send to the workflow + sig { void } + def clear_signal_name + end + + # Serialized value(s) to provide with the signal + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def signal_input + end + + # Serialized value(s) to provide with the signal + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def signal_input=(value) + end + + # Serialized value(s) to provide with the signal + sig { void } + def clear_signal_input + end + + # Deprecated. + sig { returns(String) } + def control + end + + # Deprecated. + sig { params(value: String).void } + def control=(value) + end + + # Deprecated. + sig { void } + def clear_control + end + + # Retry policy for the workflow + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # Retry policy for the workflow + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # Retry policy for the workflow + sig { void } + def clear_retry_policy + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { returns(String) } + def cron_schedule + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { params(value: String).void } + def cron_schedule=(value) + end + + # See https://docs.temporal.io/docs/content/what-is-a-temporal-cron-job/ + sig { void } + def clear_cron_schedule + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + sig { void } + def clear_header + end + + # Time to wait before dispatching the first workflow task. Cannot be used with `cron_schedule`. +# Note that the signal will be delivered with the first workflow task. If the workflow gets +# another SignalWithStartWorkflow before the delay a workflow task will be dispatched immediately +# and the rest of the delay period will be ignored, even if that request also had a delay. +# Signal via SignalWorkflowExecution will not unblock the workflow. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_start_delay + end + + # Time to wait before dispatching the first workflow task. Cannot be used with `cron_schedule`. +# Note that the signal will be delivered with the first workflow task. If the workflow gets +# another SignalWithStartWorkflow before the delay a workflow task will be dispatched immediately +# and the rest of the delay period will be ignored, even if that request also had a delay. +# Signal via SignalWorkflowExecution will not unblock the workflow. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_start_delay=(value) + end + + # Time to wait before dispatching the first workflow task. Cannot be used with `cron_schedule`. +# Note that the signal will be delivered with the first workflow task. If the workflow gets +# another SignalWithStartWorkflow before the delay a workflow task will be dispatched immediately +# and the rest of the delay period will be ignored, even if that request also had a delay. +# Signal via SignalWorkflowExecution will not unblock the workflow. + sig { void } + def clear_workflow_start_delay + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionInfo +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionInfo +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata on the workflow if it is started. This is carried over to the WorkflowExecutionInfo +# for use by user interfaces to display the fixed as-of-start summary and details of the +# workflow. + sig { void } + def clear_user_metadata + end + + # Links to be associated with the WorkflowExecutionStarted and WorkflowExecutionSignaled events. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to be associated with the WorkflowExecutionStarted and WorkflowExecutionSignaled events. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to be associated with the WorkflowExecutionStarted and WorkflowExecutionSignaled events. + sig { void } + def clear_links + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)) } + def versioning_override + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::VersioningOverride)).void } + def versioning_override=(value) + end + + # If set, takes precedence over the Versioning Behavior sent by the SDK on Workflow Task completion. +# To unset the override after the workflow is running, use UpdateWorkflowExecutionOptions. + sig { void } + def clear_versioning_override + end + + # Priority metadata + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata + sig { void } + def clear_priority + end + + # Time-skipping configuration. If not set, time skipping is disabled. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)) } + def time_skipping_config + end + + # Time-skipping configuration. If not set, time skipping is disabled. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::TimeSkippingConfig)).void } + def time_skipping_config=(value) + end + + # Time-skipping configuration. If not set, time skipping is disabled. + sig { void } + def clear_time_skipping_config + 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::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest, 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::WorkflowService::V1::SignalWithStartWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + started: T.nilable(T::Boolean), + signal_link: T.nilable(Temporalio::Api::Common::V1::Link) + ).void + end + def initialize( + run_id: "", + started: false, + signal_link: nil + ) + end + + # The run id of the workflow that was started - or just signaled, if it was already running. + sig { returns(String) } + def run_id + end + + # The run id of the workflow that was started - or just signaled, if it was already running. + sig { params(value: String).void } + def run_id=(value) + end + + # The run id of the workflow that was started - or just signaled, if it was already running. + sig { void } + def clear_run_id + end + + # If true, a new workflow was started. + sig { returns(T::Boolean) } + def started + end + + # If true, a new workflow was started. + sig { params(value: T::Boolean).void } + def started=(value) + end + + # If true, a new workflow was started. + sig { void } + def clear_started + end + + # Link to be associated with the WorkflowExecutionSignaled event. +# Added on the response to propagate the backlink. +# Available from Temporal server 1.31 and up. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link)) } + def signal_link + end + + # Link to be associated with the WorkflowExecutionSignaled event. +# Added on the response to propagate the backlink. +# Available from Temporal server 1.31 and up. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link)).void } + def signal_link=(value) + end + + # Link to be associated with the WorkflowExecutionSignaled event. +# Added on the response to propagate the backlink. +# Available from Temporal server 1.31 and up. + sig { void } + def clear_signal_link + 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::WorkflowService::V1::SignalWithStartWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionResponse, 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::WorkflowService::V1::ResetWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + reason: T.nilable(String), + workflow_task_finish_event_id: T.nilable(Integer), + request_id: T.nilable(String), + reset_reapply_type: T.nilable(T.any(Symbol, String, Integer)), + reset_reapply_exclude_types: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + post_reset_operations: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation)]), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_execution: nil, + reason: "", + workflow_task_finish_event_id: 0, + request_id: "", + reset_reapply_type: :RESET_REAPPLY_TYPE_UNSPECIFIED, + reset_reapply_exclude_types: [], + post_reset_operations: [], + identity: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # The workflow to reset. If this contains a run ID then the workflow will be reset back to the +# provided event ID in that run. Otherwise it will be reset to the provided event ID in the +# current run. In all cases the current run will be terminated and a new run started. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + # The workflow to reset. If this contains a run ID then the workflow will be reset back to the +# provided event ID in that run. Otherwise it will be reset to the provided event ID in the +# current run. In all cases the current run will be terminated and a new run started. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + # The workflow to reset. If this contains a run ID then the workflow will be reset back to the +# provided event ID in that run. Otherwise it will be reset to the provided event ID in the +# current run. In all cases the current run will be terminated and a new run started. + sig { void } + def clear_workflow_execution + end + + sig { returns(String) } + def reason + end + + sig { params(value: String).void } + def reason=(value) + end + + sig { void } + def clear_reason + end + + # The id of a `WORKFLOW_TASK_COMPLETED`,`WORKFLOW_TASK_TIMED_OUT`, `WORKFLOW_TASK_FAILED`, or +# `WORKFLOW_TASK_STARTED` event to reset to. + sig { returns(Integer) } + def workflow_task_finish_event_id + end + + # The id of a `WORKFLOW_TASK_COMPLETED`,`WORKFLOW_TASK_TIMED_OUT`, `WORKFLOW_TASK_FAILED`, or +# `WORKFLOW_TASK_STARTED` event to reset to. + sig { params(value: Integer).void } + def workflow_task_finish_event_id=(value) + end + + # The id of a `WORKFLOW_TASK_COMPLETED`,`WORKFLOW_TASK_TIMED_OUT`, `WORKFLOW_TASK_FAILED`, or +# `WORKFLOW_TASK_STARTED` event to reset to. + sig { void } + def clear_workflow_task_finish_event_id + end + + # Used to de-dupe reset requests + sig { returns(String) } + def request_id + end + + # Used to de-dupe reset requests + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe reset requests + sig { void } + def clear_request_id + end + + # Deprecated. Use `options`. +# Default: RESET_REAPPLY_TYPE_SIGNAL + sig { returns(T.any(Symbol, Integer)) } + def reset_reapply_type + end + + # Deprecated. Use `options`. +# Default: RESET_REAPPLY_TYPE_SIGNAL + sig { params(value: T.any(Symbol, String, Integer)).void } + def reset_reapply_type=(value) + end + + # Deprecated. Use `options`. +# Default: RESET_REAPPLY_TYPE_SIGNAL + sig { void } + def clear_reset_reapply_type + end + + # Event types not to be reapplied + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def reset_reapply_exclude_types + end + + # Event types not to be reapplied + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def reset_reapply_exclude_types=(value) + end + + # Event types not to be reapplied + sig { void } + def clear_reset_reapply_exclude_types + end + + # Operations to perform after the workflow has been reset. These operations will be applied +# to the *new* run of the workflow execution in the order they are provided. +# All operations are applied to the workflow before the first new workflow task is generated + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PostResetOperation)]) } + def post_reset_operations + end + + # Operations to perform after the workflow has been reset. These operations will be applied +# to the *new* run of the workflow execution in the order they are provided. +# All operations are applied to the workflow before the first new workflow task is generated + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def post_reset_operations=(value) + end + + # Operations to perform after the workflow has been reset. These operations will be applied +# to the *new* run of the workflow execution in the order they are provided. +# All operations are applied to the workflow before the first new workflow task is generated + sig { void } + def clear_post_reset_operations + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + 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::WorkflowService::V1::ResetWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionRequest, 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::WorkflowService::V1::ResetWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String) + ).void + end + def initialize( + run_id: "" + ) + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionResponse, 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::WorkflowService::V1::TerminateWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + reason: T.nilable(String), + details: T.nilable(Temporalio::Api::Common::V1::Payloads), + identity: T.nilable(String), + first_execution_run_id: T.nilable(String), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) + ).void + end + def initialize( + namespace: "", + workflow_execution: nil, + reason: "", + details: nil, + identity: "", + first_execution_run_id: "", + links: [] + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + sig { void } + def clear_workflow_execution + end + + sig { returns(String) } + def reason + end + + sig { params(value: String).void } + def reason=(value) + end + + sig { void } + def clear_reason + end + + # Serialized additional information to attach to the termination event + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def details + end + + # Serialized additional information to attach to the termination event + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def details=(value) + end + + # Serialized additional information to attach to the termination event + sig { void } + def clear_details + end + + # The identity of the worker/client + sig { returns(String) } + def identity + end + + # The identity of the worker/client + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client + sig { void } + def clear_identity + end + + # If set, this call will error if the most recent (if no run id is set on +# `workflow_execution`), or specified (if it is) workflow execution is not part of the same +# execution chain as this id. + sig { returns(String) } + def first_execution_run_id + end + + # If set, this call will error if the most recent (if no run id is set on +# `workflow_execution`), or specified (if it is) workflow execution is not part of the same +# execution chain as this id. + sig { params(value: String).void } + def first_execution_run_id=(value) + end + + # If set, this call will error if the most recent (if no run id is set on +# `workflow_execution`), or specified (if it is) workflow execution is not part of the same +# execution chain as this id. + sig { void } + def clear_first_execution_run_id + end + + # Links to be associated with the WorkflowExecutionTerminated event. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to be associated with the WorkflowExecutionTerminated event. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to be associated with the WorkflowExecutionTerminated event. + sig { void } + def clear_links + 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::WorkflowService::V1::TerminateWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionRequest, 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::WorkflowService::V1::TerminateWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::TerminateWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionResponse, 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::WorkflowService::V1::DeleteWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution) + ).void + end + def initialize( + namespace: "", + workflow_execution: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Workflow Execution to delete. If run_id is not specified, the latest one is used. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + # Workflow Execution to delete. If run_id is not specified, the latest one is used. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + # Workflow Execution to delete. If run_id is not specified, the latest one is used. + sig { void } + def clear_workflow_execution + 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::WorkflowService::V1::DeleteWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkflowExecutionRequest, 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::WorkflowService::V1::DeleteWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::DeleteWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkflowExecutionResponse, 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::WorkflowService::V1::ListOpenWorkflowExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + maximum_page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + start_time_filter: T.nilable(Temporalio::Api::Filter::V1::StartTimeFilter), + execution_filter: T.nilable(Temporalio::Api::Filter::V1::WorkflowExecutionFilter), + type_filter: T.nilable(Temporalio::Api::Filter::V1::WorkflowTypeFilter) + ).void + end + def initialize( + namespace: "", + maximum_page_size: 0, + next_page_token: "", + start_time_filter: nil, + execution_filter: nil, + type_filter: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(Integer) } + def maximum_page_size + end + + sig { params(value: Integer).void } + def maximum_page_size=(value) + end + + sig { void } + def clear_maximum_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + sig { returns(T.nilable(Temporalio::Api::Filter::V1::StartTimeFilter)) } + def start_time_filter + end + + sig { params(value: T.nilable(Temporalio::Api::Filter::V1::StartTimeFilter)).void } + def start_time_filter=(value) + end + + sig { void } + def clear_start_time_filter + end + + sig { returns(T.nilable(Temporalio::Api::Filter::V1::WorkflowExecutionFilter)) } + def execution_filter + end + + sig { params(value: T.nilable(Temporalio::Api::Filter::V1::WorkflowExecutionFilter)).void } + def execution_filter=(value) + end + + sig { void } + def clear_execution_filter + end + + sig { returns(T.nilable(Temporalio::Api::Filter::V1::WorkflowTypeFilter)) } + def type_filter + end + + sig { params(value: T.nilable(Temporalio::Api::Filter::V1::WorkflowTypeFilter)).void } + def type_filter=(value) + end + + sig { void } + def clear_type_filter + end + + sig { returns(T.nilable(Symbol)) } + def filters + 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::WorkflowService::V1::ListOpenWorkflowExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListOpenWorkflowExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListOpenWorkflowExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListOpenWorkflowExecutionsRequest, 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::WorkflowService::V1::ListOpenWorkflowExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + executions: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + executions: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]) } + def executions + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def executions=(value) + end + + sig { void } + def clear_executions + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListOpenWorkflowExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListOpenWorkflowExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListOpenWorkflowExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListOpenWorkflowExecutionsResponse, 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::WorkflowService::V1::ListClosedWorkflowExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + maximum_page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + start_time_filter: T.nilable(Temporalio::Api::Filter::V1::StartTimeFilter), + execution_filter: T.nilable(Temporalio::Api::Filter::V1::WorkflowExecutionFilter), + type_filter: T.nilable(Temporalio::Api::Filter::V1::WorkflowTypeFilter), + status_filter: T.nilable(Temporalio::Api::Filter::V1::StatusFilter) + ).void + end + def initialize( + namespace: "", + maximum_page_size: 0, + next_page_token: "", + start_time_filter: nil, + execution_filter: nil, + type_filter: nil, + status_filter: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(Integer) } + def maximum_page_size + end + + sig { params(value: Integer).void } + def maximum_page_size=(value) + end + + sig { void } + def clear_maximum_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + sig { returns(T.nilable(Temporalio::Api::Filter::V1::StartTimeFilter)) } + def start_time_filter + end + + sig { params(value: T.nilable(Temporalio::Api::Filter::V1::StartTimeFilter)).void } + def start_time_filter=(value) + end + + sig { void } + def clear_start_time_filter + end + + sig { returns(T.nilable(Temporalio::Api::Filter::V1::WorkflowExecutionFilter)) } + def execution_filter + end + + sig { params(value: T.nilable(Temporalio::Api::Filter::V1::WorkflowExecutionFilter)).void } + def execution_filter=(value) + end + + sig { void } + def clear_execution_filter + end + + sig { returns(T.nilable(Temporalio::Api::Filter::V1::WorkflowTypeFilter)) } + def type_filter + end + + sig { params(value: T.nilable(Temporalio::Api::Filter::V1::WorkflowTypeFilter)).void } + def type_filter=(value) + end + + sig { void } + def clear_type_filter + end + + sig { returns(T.nilable(Temporalio::Api::Filter::V1::StatusFilter)) } + def status_filter + end + + sig { params(value: T.nilable(Temporalio::Api::Filter::V1::StatusFilter)).void } + def status_filter=(value) + end + + sig { void } + def clear_status_filter + end + + sig { returns(T.nilable(Symbol)) } + def filters + 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::WorkflowService::V1::ListClosedWorkflowExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListClosedWorkflowExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListClosedWorkflowExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListClosedWorkflowExecutionsRequest, 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::WorkflowService::V1::ListClosedWorkflowExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + executions: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + executions: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]) } + def executions + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def executions=(value) + end + + sig { void } + def clear_executions + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListClosedWorkflowExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListClosedWorkflowExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListClosedWorkflowExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListClosedWorkflowExecutionsResponse, 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::WorkflowService::V1::ListWorkflowExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + sig { returns(String) } + def query + end + + sig { params(value: String).void } + def query=(value) + end + + sig { void } + def clear_query + 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::WorkflowService::V1::ListWorkflowExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkflowExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkflowExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkflowExecutionsRequest, 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::WorkflowService::V1::ListWorkflowExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + executions: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + executions: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]) } + def executions + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def executions=(value) + end + + sig { void } + def clear_executions + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListWorkflowExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkflowExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkflowExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkflowExecutionsResponse, 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::WorkflowService::V1::ListArchivedWorkflowExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + sig { returns(String) } + def query + end + + sig { params(value: String).void } + def query=(value) + end + + sig { void } + def clear_query + 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::WorkflowService::V1::ListArchivedWorkflowExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListArchivedWorkflowExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListArchivedWorkflowExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListArchivedWorkflowExecutionsRequest, 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::WorkflowService::V1::ListArchivedWorkflowExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + executions: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + executions: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]) } + def executions + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def executions=(value) + end + + sig { void } + def clear_executions + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListArchivedWorkflowExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListArchivedWorkflowExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListArchivedWorkflowExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListArchivedWorkflowExecutionsResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Deprecated: Use with `ListWorkflowExecutions`. +class Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + sig { returns(String) } + def query + end + + sig { params(value: String).void } + def query=(value) + end + + sig { void } + def clear_query + 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::WorkflowService::V1::ScanWorkflowExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Deprecated: Use with `ListWorkflowExecutions`. +class Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + executions: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + executions: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)]) } + def executions + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def executions=(value) + end + + sig { void } + def clear_executions + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ScanWorkflowExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsResponse, 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::WorkflowService::V1::CountWorkflowExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def query + end + + sig { params(value: String).void } + def query=(value) + end + + sig { void } + def clear_query + 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::WorkflowService::V1::CountWorkflowExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsRequest, 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::WorkflowService::V1::CountWorkflowExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + count: T.nilable(Integer), + groups: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse::AggregationGroup)]) + ).void + end + def initialize( + count: 0, + groups: [] + ) + end + + # If `query` is not grouping by any field, the count is an approximate number +# of workflows that matches the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of workflows matching the query. + sig { returns(Integer) } + def count + end + + # If `query` is not grouping by any field, the count is an approximate number +# of workflows that matches the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of workflows matching the query. + sig { params(value: Integer).void } + def count=(value) + end + + # If `query` is not grouping by any field, the count is an approximate number +# of workflows that matches the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of workflows matching the query. + sig { void } + def clear_count + end + + # `groups` contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse::AggregationGroup)]) } + def groups + end + + # `groups` contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def groups=(value) + end + + # `groups` contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { void } + def clear_groups + 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::WorkflowService::V1::CountWorkflowExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse, 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::WorkflowService::V1::GetSearchAttributesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::GetSearchAttributesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSearchAttributesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetSearchAttributesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSearchAttributesRequest, 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::WorkflowService::V1::GetSearchAttributesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + keys: T.nilable(T::Hash[String, T.any(Symbol, String, Integer)]) + ).void + end + def initialize( + keys: ::Google::Protobuf::Map.new(:string, :enum) + ) + end + + sig { returns(T::Hash[String, T.any(Symbol, Integer)]) } + def keys + end + + sig { params(value: ::Google::Protobuf::Map).void } + def keys=(value) + end + + sig { void } + def clear_keys + 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::WorkflowService::V1::GetSearchAttributesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSearchAttributesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetSearchAttributesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSearchAttributesResponse, 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::WorkflowService::V1::RespondQueryTaskCompletedRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + completed_type: T.nilable(T.any(Symbol, String, Integer)), + query_result: T.nilable(Temporalio::Api::Common::V1::Payloads), + error_message: T.nilable(String), + namespace: T.nilable(String), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + cause: T.nilable(T.any(Symbol, String, Integer)), + poller_group_id: T.nilable(String) + ).void + end + def initialize( + task_token: "", + completed_type: :QUERY_RESULT_TYPE_UNSPECIFIED, + query_result: nil, + error_message: "", + namespace: "", + failure: nil, + cause: :WORKFLOW_TASK_FAILED_CAUSE_UNSPECIFIED, + poller_group_id: "" + ) + end + + sig { returns(String) } + def task_token + end + + sig { params(value: String).void } + def task_token=(value) + end + + sig { void } + def clear_task_token + end + + sig { returns(T.any(Symbol, Integer)) } + def completed_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def completed_type=(value) + end + + sig { void } + def clear_completed_type + end + + # The result of the query. +# Mutually exclusive with `error_message` and `failure`. Set when the query succeeds. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def query_result + end + + # The result of the query. +# Mutually exclusive with `error_message` and `failure`. Set when the query succeeds. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def query_result=(value) + end + + # The result of the query. +# Mutually exclusive with `error_message` and `failure`. Set when the query succeeds. + sig { void } + def clear_query_result + end + + # A plain error message that must be set if completed_type is QUERY_RESULT_TYPE_FAILED. +# SDKs should also fill in the more complete `failure` field to provide the full context and +# support encryption of failure information. +# `error_message` will be duplicated if the `failure` field is present to support callers +# that pre-date the addition of that field, regardless of whether or not a custom failure +# converter is used. +# Mutually exclusive with `query_result`. Set when the query fails. + sig { returns(String) } + def error_message + end + + # A plain error message that must be set if completed_type is QUERY_RESULT_TYPE_FAILED. +# SDKs should also fill in the more complete `failure` field to provide the full context and +# support encryption of failure information. +# `error_message` will be duplicated if the `failure` field is present to support callers +# that pre-date the addition of that field, regardless of whether or not a custom failure +# converter is used. +# Mutually exclusive with `query_result`. Set when the query fails. + sig { params(value: String).void } + def error_message=(value) + end + + # A plain error message that must be set if completed_type is QUERY_RESULT_TYPE_FAILED. +# SDKs should also fill in the more complete `failure` field to provide the full context and +# support encryption of failure information. +# `error_message` will be duplicated if the `failure` field is present to support callers +# that pre-date the addition of that field, regardless of whether or not a custom failure +# converter is used. +# Mutually exclusive with `query_result`. Set when the query fails. + sig { void } + def clear_error_message + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # The full reason for this query failure. This field is newer than `error_message` and can be +# encoded by the SDK's failure converter to support E2E encryption of messages and stack +# traces. +# Mutually exclusive with `query_result`. Set when the query fails. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The full reason for this query failure. This field is newer than `error_message` and can be +# encoded by the SDK's failure converter to support E2E encryption of messages and stack +# traces. +# Mutually exclusive with `query_result`. Set when the query fails. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The full reason for this query failure. This field is newer than `error_message` and can be +# encoded by the SDK's failure converter to support E2E encryption of messages and stack +# traces. +# Mutually exclusive with `query_result`. Set when the query fails. + sig { void } + def clear_failure + end + + # Why did the task fail? It's important to note that many of the variants in this enum cannot +# apply to worker responses. See the type's doc for more. + sig { returns(T.any(Symbol, Integer)) } + def cause + end + + # Why did the task fail? It's important to note that many of the variants in this enum cannot +# apply to worker responses. See the type's doc for more. + sig { params(value: T.any(Symbol, String, Integer)).void } + def cause=(value) + end + + # Why did the task fail? It's important to note that many of the variants in this enum cannot +# apply to worker responses. See the type's doc for more. + sig { void } + def clear_cause + end + + # Client must forward the poller_group_id received in PollWorkflowTaskQueueResponse for proper +# routing of the response. + sig { returns(String) } + def poller_group_id + end + + # Client must forward the poller_group_id received in PollWorkflowTaskQueueResponse for proper +# routing of the response. + sig { params(value: String).void } + def poller_group_id=(value) + end + + # Client must forward the poller_group_id received in PollWorkflowTaskQueueResponse for proper +# routing of the response. + sig { void } + def clear_poller_group_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::WorkflowService::V1::RespondQueryTaskCompletedRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondQueryTaskCompletedRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondQueryTaskCompletedRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondQueryTaskCompletedRequest, 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::WorkflowService::V1::RespondQueryTaskCompletedResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RespondQueryTaskCompletedResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondQueryTaskCompletedResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondQueryTaskCompletedResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondQueryTaskCompletedResponse, 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::WorkflowService::V1::ResetStickyTaskQueueRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution) + ).void + end + def initialize( + namespace: "", + execution: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + sig { void } + def clear_execution + 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::WorkflowService::V1::ResetStickyTaskQueueRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetStickyTaskQueueRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ResetStickyTaskQueueRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetStickyTaskQueueRequest, 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::WorkflowService::V1::ResetStickyTaskQueueResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::ResetStickyTaskQueueResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetStickyTaskQueueResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ResetStickyTaskQueueResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetStickyTaskQueueResponse, 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::WorkflowService::V1::ShutdownWorkerRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + sticky_task_queue: T.nilable(String), + identity: T.nilable(String), + reason: T.nilable(String), + worker_heartbeat: T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat), + worker_instance_key: T.nilable(String), + task_queue: T.nilable(String), + task_queue_types: T.nilable(T::Array[T.any(Symbol, String, Integer)]) + ).void + end + def initialize( + namespace: "", + sticky_task_queue: "", + identity: "", + reason: "", + worker_heartbeat: nil, + worker_instance_key: "", + task_queue: "", + task_queue_types: [] + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # sticky_task_queue may not always be populated. We want to ensure all workers +# send a shutdown request to update worker state for heartbeating, as well +# as cancel pending poll calls early, instead of waiting for timeouts. + sig { returns(String) } + def sticky_task_queue + end + + # sticky_task_queue may not always be populated. We want to ensure all workers +# send a shutdown request to update worker state for heartbeating, as well +# as cancel pending poll calls early, instead of waiting for timeouts. + sig { params(value: String).void } + def sticky_task_queue=(value) + end + + # sticky_task_queue may not always be populated. We want to ensure all workers +# send a shutdown request to update worker state for heartbeating, as well +# as cancel pending poll calls early, instead of waiting for timeouts. + sig { void } + def clear_sticky_task_queue + end + + sig { returns(String) } + def identity + end + + sig { params(value: String).void } + def identity=(value) + end + + sig { void } + def clear_identity + end + + sig { returns(String) } + def reason + end + + sig { params(value: String).void } + def reason=(value) + end + + sig { void } + def clear_reason + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat)) } + def worker_heartbeat + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat)).void } + def worker_heartbeat=(value) + end + + sig { void } + def clear_worker_heartbeat + end + + # Technically this is also sent in the WorkerHeartbeat, but +# since worker heartbeating can be turned off, this needs +# to be a separate, top-level field. + sig { returns(String) } + def worker_instance_key + end + + # Technically this is also sent in the WorkerHeartbeat, but +# since worker heartbeating can be turned off, this needs +# to be a separate, top-level field. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # Technically this is also sent in the WorkerHeartbeat, but +# since worker heartbeating can be turned off, this needs +# to be a separate, top-level field. + sig { void } + def clear_worker_instance_key + end + + # Task queue name the worker is polling on. This allows server to cancel +# all outstanding poll RPC calls from SDK. This avoids a race condition that +# can lead to tasks being lost. + sig { returns(String) } + def task_queue + end + + # Task queue name the worker is polling on. This allows server to cancel +# all outstanding poll RPC calls from SDK. This avoids a race condition that +# can lead to tasks being lost. + sig { params(value: String).void } + def task_queue=(value) + end + + # Task queue name the worker is polling on. This allows server to cancel +# all outstanding poll RPC calls from SDK. This avoids a race condition that +# can lead to tasks being lost. + sig { void } + def clear_task_queue + end + + # Task queue types that help server cancel outstanding poll RPC +# calls from SDK. This avoids a race condition that can lead to tasks being lost. + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def task_queue_types + end + + # Task queue types that help server cancel outstanding poll RPC +# calls from SDK. This avoids a race condition that can lead to tasks being lost. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def task_queue_types=(value) + end + + # Task queue types that help server cancel outstanding poll RPC +# calls from SDK. This avoids a race condition that can lead to tasks being lost. + sig { void } + def clear_task_queue_types + 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::WorkflowService::V1::ShutdownWorkerRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ShutdownWorkerRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ShutdownWorkerRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ShutdownWorkerRequest, 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::WorkflowService::V1::ShutdownWorkerResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::ShutdownWorkerResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ShutdownWorkerResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ShutdownWorkerResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ShutdownWorkerResponse, 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::WorkflowService::V1::QueryWorkflowRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + query: T.nilable(Temporalio::Api::Query::V1::WorkflowQuery), + query_reject_condition: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + namespace: "", + execution: nil, + query: nil, + query_reject_condition: :QUERY_REJECT_CONDITION_UNSPECIFIED + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + sig { void } + def clear_execution + end + + sig { returns(T.nilable(Temporalio::Api::Query::V1::WorkflowQuery)) } + def query + end + + sig { params(value: T.nilable(Temporalio::Api::Query::V1::WorkflowQuery)).void } + def query=(value) + end + + sig { void } + def clear_query + end + + # QueryRejectCondition can used to reject the query if workflow state does not satisfy condition. +# Default: QUERY_REJECT_CONDITION_NONE. + sig { returns(T.any(Symbol, Integer)) } + def query_reject_condition + end + + # QueryRejectCondition can used to reject the query if workflow state does not satisfy condition. +# Default: QUERY_REJECT_CONDITION_NONE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def query_reject_condition=(value) + end + + # QueryRejectCondition can used to reject the query if workflow state does not satisfy condition. +# Default: QUERY_REJECT_CONDITION_NONE. + sig { void } + def clear_query_reject_condition + 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::WorkflowService::V1::QueryWorkflowRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::QueryWorkflowRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::QueryWorkflowRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::QueryWorkflowRequest, 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::WorkflowService::V1::QueryWorkflowResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + query_result: T.nilable(Temporalio::Api::Common::V1::Payloads), + query_rejected: T.nilable(Temporalio::Api::Query::V1::QueryRejected) + ).void + end + def initialize( + query_result: nil, + query_rejected: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def query_result + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def query_result=(value) + end + + sig { void } + def clear_query_result + end + + sig { returns(T.nilable(Temporalio::Api::Query::V1::QueryRejected)) } + def query_rejected + end + + sig { params(value: T.nilable(Temporalio::Api::Query::V1::QueryRejected)).void } + def query_rejected=(value) + end + + sig { void } + def clear_query_rejected + 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::WorkflowService::V1::QueryWorkflowResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::QueryWorkflowResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::QueryWorkflowResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::QueryWorkflowResponse, 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::WorkflowService::V1::DescribeWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution) + ).void + end + def initialize( + namespace: "", + execution: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + sig { void } + def clear_execution + 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::WorkflowService::V1::DescribeWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionRequest, 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::WorkflowService::V1::DescribeWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + execution_config: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionConfig), + workflow_execution_info: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo), + pending_activities: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo)]), + pending_children: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PendingChildExecutionInfo)]), + pending_workflow_task: T.nilable(Temporalio::Api::Workflow::V1::PendingWorkflowTaskInfo), + callbacks: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::CallbackInfo)]), + pending_nexus_operations: T.nilable(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PendingNexusOperationInfo)]), + workflow_extended_info: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionExtendedInfo) + ).void + end + def initialize( + execution_config: nil, + workflow_execution_info: nil, + pending_activities: [], + pending_children: [], + pending_workflow_task: nil, + callbacks: [], + pending_nexus_operations: [], + workflow_extended_info: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionConfig)) } + def execution_config + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionConfig)).void } + def execution_config=(value) + end + + sig { void } + def clear_execution_config + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)) } + def workflow_execution_info + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo)).void } + def workflow_execution_info=(value) + end + + sig { void } + def clear_workflow_execution_info + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PendingActivityInfo)]) } + def pending_activities + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def pending_activities=(value) + end + + sig { void } + def clear_pending_activities + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PendingChildExecutionInfo)]) } + def pending_children + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def pending_children=(value) + end + + sig { void } + def clear_pending_children + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::PendingWorkflowTaskInfo)) } + def pending_workflow_task + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::PendingWorkflowTaskInfo)).void } + def pending_workflow_task=(value) + end + + sig { void } + def clear_pending_workflow_task + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::CallbackInfo)]) } + def callbacks + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def callbacks=(value) + end + + sig { void } + def clear_callbacks + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Workflow::V1::PendingNexusOperationInfo)]) } + def pending_nexus_operations + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def pending_nexus_operations=(value) + end + + sig { void } + def clear_pending_nexus_operations + end + + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionExtendedInfo)) } + def workflow_extended_info + end + + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionExtendedInfo)).void } + def workflow_extended_info=(value) + end + + sig { void } + def clear_workflow_extended_info + 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::WorkflowService::V1::DescribeWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# (-- api-linter: core::0203::optional=disabled +# aip.dev/not-precedent: field_behavior annotation not available in our gogo fork --) +class Temporalio::Api::WorkflowService::V1::DescribeTaskQueueRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + task_queue_type: T.nilable(T.any(Symbol, String, Integer)), + report_stats: T.nilable(T::Boolean), + report_config: T.nilable(T::Boolean), + include_task_queue_status: T.nilable(T::Boolean), + api_mode: T.nilable(T.any(Symbol, String, Integer)), + versions: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueVersionSelection), + task_queue_types: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + report_pollers: T.nilable(T::Boolean), + report_task_reachability: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace: "", + task_queue: nil, + task_queue_type: :TASK_QUEUE_TYPE_UNSPECIFIED, + report_stats: false, + report_config: false, + include_task_queue_status: false, + api_mode: :DESCRIBE_TASK_QUEUE_MODE_UNSPECIFIED, + versions: nil, + task_queue_types: [], + report_pollers: false, + report_task_reachability: false + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Sticky queues are not supported in deprecated ENHANCED mode. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + # Sticky queues are not supported in deprecated ENHANCED mode. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + # Sticky queues are not supported in deprecated ENHANCED mode. + sig { void } + def clear_task_queue + end + + # If unspecified (TASK_QUEUE_TYPE_UNSPECIFIED), then default value (TASK_QUEUE_TYPE_WORKFLOW) will be used. +# Only supported in default mode (use `task_queue_types` in ENHANCED mode instead). + sig { returns(T.any(Symbol, Integer)) } + def task_queue_type + end + + # If unspecified (TASK_QUEUE_TYPE_UNSPECIFIED), then default value (TASK_QUEUE_TYPE_WORKFLOW) will be used. +# Only supported in default mode (use `task_queue_types` in ENHANCED mode instead). + sig { params(value: T.any(Symbol, String, Integer)).void } + def task_queue_type=(value) + end + + # If unspecified (TASK_QUEUE_TYPE_UNSPECIFIED), then default value (TASK_QUEUE_TYPE_WORKFLOW) will be used. +# Only supported in default mode (use `task_queue_types` in ENHANCED mode instead). + sig { void } + def clear_task_queue_type + end + + # Report stats for the requested task queue type(s). + sig { returns(T::Boolean) } + def report_stats + end + + # Report stats for the requested task queue type(s). + sig { params(value: T::Boolean).void } + def report_stats=(value) + end + + # Report stats for the requested task queue type(s). + sig { void } + def clear_report_stats + end + + # Report Task Queue Config + sig { returns(T::Boolean) } + def report_config + end + + # Report Task Queue Config + sig { params(value: T::Boolean).void } + def report_config=(value) + end + + # Report Task Queue Config + sig { void } + def clear_report_config + end + + # Deprecated, use `report_stats` instead. +# If true, the task queue status will be included in the response. + sig { returns(T::Boolean) } + def include_task_queue_status + end + + # Deprecated, use `report_stats` instead. +# If true, the task queue status will be included in the response. + sig { params(value: T::Boolean).void } + def include_task_queue_status=(value) + end + + # Deprecated, use `report_stats` instead. +# If true, the task queue status will be included in the response. + sig { void } + def clear_include_task_queue_status + end + + # Deprecated. ENHANCED mode is also being deprecated. +# Select the API mode to use for this request: DEFAULT mode (if unset) or ENHANCED mode. +# Consult the documentation for each field to understand which mode it is supported in. + sig { returns(T.any(Symbol, Integer)) } + def api_mode + end + + # Deprecated. ENHANCED mode is also being deprecated. +# Select the API mode to use for this request: DEFAULT mode (if unset) or ENHANCED mode. +# Consult the documentation for each field to understand which mode it is supported in. + sig { params(value: T.any(Symbol, String, Integer)).void } + def api_mode=(value) + end + + # Deprecated. ENHANCED mode is also being deprecated. +# Select the API mode to use for this request: DEFAULT mode (if unset) or ENHANCED mode. +# Consult the documentation for each field to understand which mode it is supported in. + sig { void } + def clear_api_mode + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Optional. If not provided, the result for the default Build ID will be returned. The default Build ID is the one +# mentioned in the first unconditional Assignment Rule. If there is no default Build ID, the result for the +# unversioned queue will be returned. +# (-- api-linter: core::0140::prepositions --) + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueVersionSelection)) } + def versions + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Optional. If not provided, the result for the default Build ID will be returned. The default Build ID is the one +# mentioned in the first unconditional Assignment Rule. If there is no default Build ID, the result for the +# unversioned queue will be returned. +# (-- api-linter: core::0140::prepositions --) + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueVersionSelection)).void } + def versions=(value) + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Optional. If not provided, the result for the default Build ID will be returned. The default Build ID is the one +# mentioned in the first unconditional Assignment Rule. If there is no default Build ID, the result for the +# unversioned queue will be returned. +# (-- api-linter: core::0140::prepositions --) + sig { void } + def clear_versions + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Task queue types to report info about. If not specified, all types are considered. + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def task_queue_types + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Task queue types to report info about. If not specified, all types are considered. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def task_queue_types=(value) + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Task queue types to report info about. If not specified, all types are considered. + sig { void } + def clear_task_queue_types + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Report list of pollers for requested task queue types and versions. + sig { returns(T::Boolean) } + def report_pollers + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Report list of pollers for requested task queue types and versions. + sig { params(value: T::Boolean).void } + def report_pollers=(value) + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Report list of pollers for requested task queue types and versions. + sig { void } + def clear_report_pollers + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Report task reachability for the requested versions and all task types (task reachability is not reported +# per task type). + sig { returns(T::Boolean) } + def report_task_reachability + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Report task reachability for the requested versions and all task types (task reachability is not reported +# per task type). + sig { params(value: T::Boolean).void } + def report_task_reachability=(value) + end + + # Deprecated (as part of the ENHANCED mode deprecation). +# Report task reachability for the requested versions and all task types (task reachability is not reported +# per task type). + sig { void } + def clear_report_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::WorkflowService::V1::DescribeTaskQueueRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeTaskQueueRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeTaskQueueRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeTaskQueueRequest, 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::WorkflowService::V1::DescribeTaskQueueResponse + 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), + stats_by_priority_key: T.nilable(T::Hash[Integer, T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)]), + versioning_info: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueVersioningInfo), + config: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueConfig), + effective_rate_limit: T.nilable(Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse::EffectiveRateLimit), + task_queue_status: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStatus), + versions_info: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueVersionInfo)]) + ).void + end + def initialize( + pollers: [], + stats: nil, + stats_by_priority_key: ::Google::Protobuf::Map.new(:int32, :message, Temporalio::Api::TaskQueue::V1::TaskQueueStats), + versioning_info: nil, + config: nil, + effective_rate_limit: nil, + task_queue_status: nil, + versions_info: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::TaskQueue::V1::TaskQueueVersionInfo) + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerInfo)]) } + def pollers + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def pollers=(value) + end + + sig { void } + def clear_pollers + end + + # Statistics for the task queue. +# Only set if `report_stats` is set on the request. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)) } + def stats + end + + # Statistics for the task queue. +# Only set if `report_stats` is set on the request. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)).void } + def stats=(value) + end + + # Statistics for the task queue. +# Only set if `report_stats` is set on the request. + sig { void } + def clear_stats + end + + # Task queue stats breakdown by priority key. Only contains actively used priority keys. +# Only set if `report_stats` is set on the request. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "by" is used to clarify the keys and values. --) + sig { returns(T::Hash[Integer, T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)]) } + def stats_by_priority_key + end + + # Task queue stats breakdown by priority key. Only contains actively used priority keys. +# Only set if `report_stats` is set on the request. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "by" is used to clarify the keys and values. --) + sig { params(value: ::Google::Protobuf::Map).void } + def stats_by_priority_key=(value) + end + + # Task queue stats breakdown by priority key. Only contains actively used priority keys. +# Only set if `report_stats` is set on the request. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "by" is used to clarify the keys and values. --) + sig { void } + def clear_stats_by_priority_key + end + + # Specifies which Worker Deployment Version(s) Server routes this Task Queue's tasks to. +# When not present, it means the tasks are routed to Unversioned workers (workers with +# UNVERSIONED or unspecified WorkerVersioningMode.) +# Task Queue Versioning info is updated indirectly by calling SetWorkerDeploymentCurrentVersion +# and SetWorkerDeploymentRampingVersion on Worker Deployments. +# Note: This information is not relevant to Pinned workflow executions and their activities as +# they are always routed to their Pinned Deployment Version. However, new workflow executions +# are typically not Pinned until they complete their first task (unless they are started with +# a Pinned VersioningOverride or are Child Workflows of a Pinned parent). + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueVersioningInfo)) } + def versioning_info + end + + # Specifies which Worker Deployment Version(s) Server routes this Task Queue's tasks to. +# When not present, it means the tasks are routed to Unversioned workers (workers with +# UNVERSIONED or unspecified WorkerVersioningMode.) +# Task Queue Versioning info is updated indirectly by calling SetWorkerDeploymentCurrentVersion +# and SetWorkerDeploymentRampingVersion on Worker Deployments. +# Note: This information is not relevant to Pinned workflow executions and their activities as +# they are always routed to their Pinned Deployment Version. However, new workflow executions +# are typically not Pinned until they complete their first task (unless they are started with +# a Pinned VersioningOverride or are Child Workflows of a Pinned parent). + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueVersioningInfo)).void } + def versioning_info=(value) + end + + # Specifies which Worker Deployment Version(s) Server routes this Task Queue's tasks to. +# When not present, it means the tasks are routed to Unversioned workers (workers with +# UNVERSIONED or unspecified WorkerVersioningMode.) +# Task Queue Versioning info is updated indirectly by calling SetWorkerDeploymentCurrentVersion +# and SetWorkerDeploymentRampingVersion on Worker Deployments. +# Note: This information is not relevant to Pinned workflow executions and their activities as +# they are always routed to their Pinned Deployment Version. However, new workflow executions +# are typically not Pinned until they complete their first task (unless they are started with +# a Pinned VersioningOverride or are Child Workflows of a Pinned parent). + sig { void } + def clear_versioning_info + end + + # Only populated if report_task_queue_config is set to true. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueConfig)) } + def config + end + + # Only populated if report_task_queue_config is set to true. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueConfig)).void } + def config=(value) + end + + # Only populated if report_task_queue_config is set to true. + sig { void } + def clear_config + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse::EffectiveRateLimit)) } + def effective_rate_limit + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse::EffectiveRateLimit)).void } + def effective_rate_limit=(value) + end + + sig { void } + def clear_effective_rate_limit + end + + # Deprecated. +# Status of the task queue. Only populated when `include_task_queue_status` is set to true in the request. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStatus)) } + def task_queue_status + end + + # Deprecated. +# Status of the task queue. Only populated when `include_task_queue_status` is set to true in the request. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStatus)).void } + def task_queue_status=(value) + end + + # Deprecated. +# Status of the task queue. Only populated when `include_task_queue_status` is set to true in the request. + sig { void } + def clear_task_queue_status + end + + # Deprecated. +# Only returned in ENHANCED mode. +# This map contains Task Queue information for each Build ID. Empty string as key value means unversioned. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueVersionInfo)]) } + def versions_info + end + + # Deprecated. +# Only returned in ENHANCED mode. +# This map contains Task Queue information for each Build ID. Empty string as key value means unversioned. + sig { params(value: ::Google::Protobuf::Map).void } + def versions_info=(value) + end + + # Deprecated. +# Only returned in ENHANCED mode. +# This map contains Task Queue information for each Build ID. Empty string as key value means unversioned. + sig { void } + def clear_versions_info + 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::WorkflowService::V1::DescribeTaskQueueResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse, 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::WorkflowService::V1::GetClusterInfoRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::GetClusterInfoRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetClusterInfoRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetClusterInfoRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetClusterInfoRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# GetClusterInfoResponse contains information about Temporal cluster. +class Temporalio::Api::WorkflowService::V1::GetClusterInfoResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + supported_clients: T.nilable(T::Hash[String, String]), + server_version: T.nilable(String), + cluster_id: T.nilable(String), + version_info: T.nilable(Temporalio::Api::Version::V1::VersionInfo), + cluster_name: T.nilable(String), + history_shard_count: T.nilable(Integer), + persistence_store: T.nilable(String), + visibility_store: T.nilable(String), + initial_failover_version: T.nilable(Integer), + failover_version_increment: T.nilable(Integer) + ).void + end + def initialize( + supported_clients: ::Google::Protobuf::Map.new(:string, :string), + server_version: "", + cluster_id: "", + version_info: nil, + cluster_name: "", + history_shard_count: 0, + persistence_store: "", + visibility_store: "", + initial_failover_version: 0, + failover_version_increment: 0 + ) + end + + # Key is client name i.e "temporal-go", "temporal-java", or "temporal-cli". +# Value is ranges of supported versions of this client i.e ">1.1.1 <=1.4.0 || ^5.0.0". + sig { returns(T::Hash[String, String]) } + def supported_clients + end + + # Key is client name i.e "temporal-go", "temporal-java", or "temporal-cli". +# Value is ranges of supported versions of this client i.e ">1.1.1 <=1.4.0 || ^5.0.0". + sig { params(value: ::Google::Protobuf::Map).void } + def supported_clients=(value) + end + + # Key is client name i.e "temporal-go", "temporal-java", or "temporal-cli". +# Value is ranges of supported versions of this client i.e ">1.1.1 <=1.4.0 || ^5.0.0". + sig { void } + def clear_supported_clients + end + + sig { returns(String) } + def server_version + end + + sig { params(value: String).void } + def server_version=(value) + end + + sig { void } + def clear_server_version + end + + sig { returns(String) } + def cluster_id + end + + sig { params(value: String).void } + def cluster_id=(value) + end + + sig { void } + def clear_cluster_id + end + + sig { returns(T.nilable(Temporalio::Api::Version::V1::VersionInfo)) } + def version_info + end + + sig { params(value: T.nilable(Temporalio::Api::Version::V1::VersionInfo)).void } + def version_info=(value) + end + + sig { void } + def clear_version_info + end + + sig { returns(String) } + def cluster_name + end + + sig { params(value: String).void } + def cluster_name=(value) + end + + sig { void } + def clear_cluster_name + end + + sig { returns(Integer) } + def history_shard_count + end + + sig { params(value: Integer).void } + def history_shard_count=(value) + end + + sig { void } + def clear_history_shard_count + end + + sig { returns(String) } + def persistence_store + end + + sig { params(value: String).void } + def persistence_store=(value) + end + + sig { void } + def clear_persistence_store + end + + sig { returns(String) } + def visibility_store + end + + sig { params(value: String).void } + def visibility_store=(value) + end + + sig { void } + def clear_visibility_store + end + + sig { returns(Integer) } + def initial_failover_version + end + + sig { params(value: Integer).void } + def initial_failover_version=(value) + end + + sig { void } + def clear_initial_failover_version + end + + sig { returns(Integer) } + def failover_version_increment + end + + sig { params(value: Integer).void } + def failover_version_increment=(value) + end + + sig { void } + def clear_failover_version_increment + 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::WorkflowService::V1::GetClusterInfoResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetClusterInfoResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetClusterInfoResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetClusterInfoResponse, 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::WorkflowService::V1::GetSystemInfoRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::GetSystemInfoRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSystemInfoRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetSystemInfoRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSystemInfoRequest, 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::WorkflowService::V1::GetSystemInfoResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + server_version: T.nilable(String), + capabilities: T.nilable(Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse::Capabilities) + ).void + end + def initialize( + server_version: "", + capabilities: nil + ) + end + + # Version of the server. + sig { returns(String) } + def server_version + end + + # Version of the server. + sig { params(value: String).void } + def server_version=(value) + end + + # Version of the server. + sig { void } + def clear_server_version + end + + # All capabilities the system supports. + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse::Capabilities)) } + def capabilities + end + + # All capabilities the system supports. + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse::Capabilities)).void } + def capabilities=(value) + end + + # All capabilities the system supports. + sig { void } + def clear_capabilities + 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::WorkflowService::V1::GetSystemInfoResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse, 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::WorkflowService::V1::ListTaskQueuePartitionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue) + ).void + end + def initialize( + namespace: "", + task_queue: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + 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::WorkflowService::V1::ListTaskQueuePartitionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListTaskQueuePartitionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListTaskQueuePartitionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListTaskQueuePartitionsRequest, 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::WorkflowService::V1::ListTaskQueuePartitionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_task_queue_partitions: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueuePartitionMetadata)]), + workflow_task_queue_partitions: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueuePartitionMetadata)]) + ).void + end + def initialize( + activity_task_queue_partitions: [], + workflow_task_queue_partitions: [] + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueuePartitionMetadata)]) } + def activity_task_queue_partitions + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def activity_task_queue_partitions=(value) + end + + sig { void } + def clear_activity_task_queue_partitions + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueuePartitionMetadata)]) } + def workflow_task_queue_partitions + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def workflow_task_queue_partitions=(value) + end + + sig { void } + def clear_workflow_task_queue_partitions + 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::WorkflowService::V1::ListTaskQueuePartitionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListTaskQueuePartitionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListTaskQueuePartitionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListTaskQueuePartitionsResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# (-- api-linter: core::0203::optional=disabled +# aip.dev/not-precedent: field_behavior annotation not available in our gogo fork --) +class Temporalio::Api::WorkflowService::V1::CreateScheduleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + schedule_id: T.nilable(String), + schedule: T.nilable(Temporalio::Api::Schedule::V1::Schedule), + initial_patch: T.nilable(Temporalio::Api::Schedule::V1::SchedulePatch), + identity: T.nilable(String), + request_id: T.nilable(String), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes) + ).void + end + def initialize( + namespace: "", + schedule_id: "", + schedule: nil, + initial_patch: nil, + identity: "", + request_id: "", + memo: nil, + search_attributes: nil + ) + end + + # The namespace the schedule should be created in. + sig { returns(String) } + def namespace + end + + # The namespace the schedule should be created in. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace the schedule should be created in. + sig { void } + def clear_namespace + end + + # The id of the new schedule. + sig { returns(String) } + def schedule_id + end + + # The id of the new schedule. + sig { params(value: String).void } + def schedule_id=(value) + end + + # The id of the new schedule. + sig { void } + def clear_schedule_id + end + + # The schedule spec, policies, action, and initial state. + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::Schedule)) } + def schedule + end + + # The schedule spec, policies, action, and initial state. + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::Schedule)).void } + def schedule=(value) + end + + # The schedule spec, policies, action, and initial state. + sig { void } + def clear_schedule + end + + # Optional initial patch (e.g. to run the action once immediately). + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::SchedulePatch)) } + def initial_patch + end + + # Optional initial patch (e.g. to run the action once immediately). + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::SchedulePatch)).void } + def initial_patch=(value) + end + + # Optional initial patch (e.g. to run the action once immediately). + sig { void } + def clear_initial_patch + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. + sig { returns(String) } + def request_id + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. + sig { void } + def clear_request_id + end + + # Memo and search attributes to attach to the schedule itself. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + # Memo and search attributes to attach to the schedule itself. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + # Memo and search attributes to attach to the schedule itself. + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + 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::WorkflowService::V1::CreateScheduleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateScheduleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CreateScheduleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateScheduleRequest, 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::WorkflowService::V1::CreateScheduleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + conflict_token: T.nilable(String) + ).void + end + def initialize( + conflict_token: "" + ) + end + + sig { returns(String) } + def conflict_token + end + + sig { params(value: String).void } + def conflict_token=(value) + end + + sig { void } + def clear_conflict_token + 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::WorkflowService::V1::CreateScheduleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateScheduleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CreateScheduleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateScheduleResponse, 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::WorkflowService::V1::DescribeScheduleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + schedule_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + schedule_id: "" + ) + end + + # The namespace of the schedule to describe. + sig { returns(String) } + def namespace + end + + # The namespace of the schedule to describe. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace of the schedule to describe. + sig { void } + def clear_namespace + end + + # The id of the schedule to describe. + sig { returns(String) } + def schedule_id + end + + # The id of the schedule to describe. + sig { params(value: String).void } + def schedule_id=(value) + end + + # The id of the schedule to describe. + sig { void } + def clear_schedule_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::WorkflowService::V1::DescribeScheduleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeScheduleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeScheduleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeScheduleRequest, 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::WorkflowService::V1::DescribeScheduleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + schedule: T.nilable(Temporalio::Api::Schedule::V1::Schedule), + info: T.nilable(Temporalio::Api::Schedule::V1::ScheduleInfo), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + conflict_token: T.nilable(String) + ).void + end + def initialize( + schedule: nil, + info: nil, + memo: nil, + search_attributes: nil, + conflict_token: "" + ) + end + + # The complete current schedule details. This may not match the schedule as +# created because: +# - some types of schedule specs may get compiled into others (e.g. +# CronString into StructuredCalendarSpec) +# - some unspecified fields may be replaced by defaults +# - some fields in the state are modified automatically +# - the schedule may have been modified by UpdateSchedule or PatchSchedule + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::Schedule)) } + def schedule + end + + # The complete current schedule details. This may not match the schedule as +# created because: +# - some types of schedule specs may get compiled into others (e.g. +# CronString into StructuredCalendarSpec) +# - some unspecified fields may be replaced by defaults +# - some fields in the state are modified automatically +# - the schedule may have been modified by UpdateSchedule or PatchSchedule + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::Schedule)).void } + def schedule=(value) + end + + # The complete current schedule details. This may not match the schedule as +# created because: +# - some types of schedule specs may get compiled into others (e.g. +# CronString into StructuredCalendarSpec) +# - some unspecified fields may be replaced by defaults +# - some fields in the state are modified automatically +# - the schedule may have been modified by UpdateSchedule or PatchSchedule + sig { void } + def clear_schedule + end + + # Extra schedule state info. + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::ScheduleInfo)) } + def info + end + + # Extra schedule state info. + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::ScheduleInfo)).void } + def info=(value) + end + + # Extra schedule state info. + sig { void } + def clear_info + end + + # The memo and search attributes that the schedule was created with. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + # The memo and search attributes that the schedule was created with. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + # The memo and search attributes that the schedule was created with. + sig { void } + def clear_memo + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + sig { void } + def clear_search_attributes + end + + # This value can be passed back to UpdateSchedule to ensure that the +# schedule was not modified between a Describe and an Update, which could +# lead to lost updates and other confusion. + sig { returns(String) } + def conflict_token + end + + # This value can be passed back to UpdateSchedule to ensure that the +# schedule was not modified between a Describe and an Update, which could +# lead to lost updates and other confusion. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This value can be passed back to UpdateSchedule to ensure that the +# schedule was not modified between a Describe and an Update, which could +# lead to lost updates and other confusion. + sig { void } + def clear_conflict_token + 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::WorkflowService::V1::DescribeScheduleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeScheduleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeScheduleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeScheduleResponse, 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::WorkflowService::V1::UpdateScheduleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + schedule_id: T.nilable(String), + schedule: T.nilable(Temporalio::Api::Schedule::V1::Schedule), + conflict_token: T.nilable(String), + identity: T.nilable(String), + request_id: T.nilable(String), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + memo: T.nilable(Temporalio::Api::Common::V1::Memo) + ).void + end + def initialize( + namespace: "", + schedule_id: "", + schedule: nil, + conflict_token: "", + identity: "", + request_id: "", + search_attributes: nil, + memo: nil + ) + end + + # The namespace of the schedule to update. + sig { returns(String) } + def namespace + end + + # The namespace of the schedule to update. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace of the schedule to update. + sig { void } + def clear_namespace + end + + # The id of the schedule to update. + sig { returns(String) } + def schedule_id + end + + # The id of the schedule to update. + sig { params(value: String).void } + def schedule_id=(value) + end + + # The id of the schedule to update. + sig { void } + def clear_schedule_id + end + + # The new schedule. The four main fields of the schedule (spec, action, +# policies, state) are replaced completely by the values in this message. + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::Schedule)) } + def schedule + end + + # The new schedule. The four main fields of the schedule (spec, action, +# policies, state) are replaced completely by the values in this message. + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::Schedule)).void } + def schedule=(value) + end + + # The new schedule. The four main fields of the schedule (spec, action, +# policies, state) are replaced completely by the values in this message. + sig { void } + def clear_schedule + end + + # This can be the value of conflict_token from a DescribeScheduleResponse, +# which will cause this request to fail if the schedule has been modified +# between the Describe and this Update. +# If missing, the schedule will be updated unconditionally. + sig { returns(String) } + def conflict_token + end + + # This can be the value of conflict_token from a DescribeScheduleResponse, +# which will cause this request to fail if the schedule has been modified +# between the Describe and this Update. +# If missing, the schedule will be updated unconditionally. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This can be the value of conflict_token from a DescribeScheduleResponse, +# which will cause this request to fail if the schedule has been modified +# between the Describe and this Update. +# If missing, the schedule will be updated unconditionally. + sig { void } + def clear_conflict_token + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this update request for idempotence. Typically UUIDv4. + sig { returns(String) } + def request_id + end + + # A unique identifier for this update request for idempotence. Typically UUIDv4. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this update request for idempotence. Typically UUIDv4. + sig { void } + def clear_request_id + end + + # Schedule search attributes to be updated. +# Do not set this field if you do not want to update the search attributes. +# A non-null empty object will set the search attributes to an empty map. +# Note: you cannot only update the search attributes with `UpdateScheduleRequest`, +# you must also set the `schedule` field; otherwise, it will unset the schedule. + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # Schedule search attributes to be updated. +# Do not set this field if you do not want to update the search attributes. +# A non-null empty object will set the search attributes to an empty map. +# Note: you cannot only update the search attributes with `UpdateScheduleRequest`, +# you must also set the `schedule` field; otherwise, it will unset the schedule. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # Schedule search attributes to be updated. +# Do not set this field if you do not want to update the search attributes. +# A non-null empty object will set the search attributes to an empty map. +# Note: you cannot only update the search attributes with `UpdateScheduleRequest`, +# you must also set the `schedule` field; otherwise, it will unset the schedule. + sig { void } + def clear_search_attributes + end + + # Schedule memo to replace. If set, replaces the entire memo. +# Do not set this field if you do not want to update the memo. +# A non-null empty object will clear the memo. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + # Schedule memo to replace. If set, replaces the entire memo. +# Do not set this field if you do not want to update the memo. +# A non-null empty object will clear the memo. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + # Schedule memo to replace. If set, replaces the entire memo. +# Do not set this field if you do not want to update the memo. +# A non-null empty object will clear the memo. + sig { void } + def clear_memo + 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::WorkflowService::V1::UpdateScheduleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateScheduleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateScheduleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateScheduleRequest, 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::WorkflowService::V1::UpdateScheduleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::UpdateScheduleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateScheduleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateScheduleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateScheduleResponse, 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::WorkflowService::V1::PatchScheduleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + schedule_id: T.nilable(String), + patch: T.nilable(Temporalio::Api::Schedule::V1::SchedulePatch), + identity: T.nilable(String), + request_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + schedule_id: "", + patch: nil, + identity: "", + request_id: "" + ) + end + + # The namespace of the schedule to patch. + sig { returns(String) } + def namespace + end + + # The namespace of the schedule to patch. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace of the schedule to patch. + sig { void } + def clear_namespace + end + + # The id of the schedule to patch. + sig { returns(String) } + def schedule_id + end + + # The id of the schedule to patch. + sig { params(value: String).void } + def schedule_id=(value) + end + + # The id of the schedule to patch. + sig { void } + def clear_schedule_id + end + + sig { returns(T.nilable(Temporalio::Api::Schedule::V1::SchedulePatch)) } + def patch + end + + sig { params(value: T.nilable(Temporalio::Api::Schedule::V1::SchedulePatch)).void } + def patch=(value) + end + + sig { void } + def clear_patch + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this update request for idempotence. Typically UUIDv4. + sig { returns(String) } + def request_id + end + + # A unique identifier for this update request for idempotence. Typically UUIDv4. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this update request for idempotence. Typically UUIDv4. + sig { void } + def clear_request_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::WorkflowService::V1::PatchScheduleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PatchScheduleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PatchScheduleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PatchScheduleRequest, 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::WorkflowService::V1::PatchScheduleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::PatchScheduleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PatchScheduleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PatchScheduleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PatchScheduleResponse, 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::WorkflowService::V1::ListScheduleMatchingTimesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + schedule_id: T.nilable(String), + start_time: T.nilable(Google::Protobuf::Timestamp), + end_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + namespace: "", + schedule_id: "", + start_time: nil, + end_time: nil + ) + end + + # The namespace of the schedule to query. + sig { returns(String) } + def namespace + end + + # The namespace of the schedule to query. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace of the schedule to query. + sig { void } + def clear_namespace + end + + # The id of the schedule to query. + sig { returns(String) } + def schedule_id + end + + # The id of the schedule to query. + sig { params(value: String).void } + def schedule_id=(value) + end + + # The id of the schedule to query. + sig { void } + def clear_schedule_id + end + + # Time range to query. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # Time range to query. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # Time range to query. + sig { void } + def clear_start_time + end + + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def end_time + end + + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def end_time=(value) + end + + sig { void } + def clear_end_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::WorkflowService::V1::ListScheduleMatchingTimesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListScheduleMatchingTimesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListScheduleMatchingTimesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListScheduleMatchingTimesRequest, 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::WorkflowService::V1::ListScheduleMatchingTimesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_time: T.nilable(T::Array[T.nilable(Google::Protobuf::Timestamp)]) + ).void + end + def initialize( + start_time: [] + ) + end + + sig { returns(T::Array[T.nilable(Google::Protobuf::Timestamp)]) } + def start_time + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def start_time=(value) + end + + sig { void } + def clear_start_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::WorkflowService::V1::ListScheduleMatchingTimesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListScheduleMatchingTimesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListScheduleMatchingTimesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListScheduleMatchingTimesResponse, 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::WorkflowService::V1::DeleteScheduleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + schedule_id: T.nilable(String), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + schedule_id: "", + identity: "" + ) + end + + # The namespace of the schedule to delete. + sig { returns(String) } + def namespace + end + + # The namespace of the schedule to delete. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace of the schedule to delete. + sig { void } + def clear_namespace + end + + # The id of the schedule to delete. + sig { returns(String) } + def schedule_id + end + + # The id of the schedule to delete. + sig { params(value: String).void } + def schedule_id=(value) + end + + # The id of the schedule to delete. + sig { void } + def clear_schedule_id + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + 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::WorkflowService::V1::DeleteScheduleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteScheduleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteScheduleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteScheduleRequest, 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::WorkflowService::V1::DeleteScheduleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::DeleteScheduleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteScheduleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteScheduleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteScheduleResponse, 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::WorkflowService::V1::ListSchedulesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + maximum_page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + maximum_page_size: 0, + next_page_token: "", + query: "" + ) + end + + # The namespace to list schedules in. + sig { returns(String) } + def namespace + end + + # The namespace to list schedules in. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace to list schedules in. + sig { void } + def clear_namespace + end + + # How many to return at once. + sig { returns(Integer) } + def maximum_page_size + end + + # How many to return at once. + sig { params(value: Integer).void } + def maximum_page_size=(value) + end + + # How many to return at once. + sig { void } + def clear_maximum_page_size + end + + # Token to get the next page of results. + sig { returns(String) } + def next_page_token + end + + # Token to get the next page of results. + sig { params(value: String).void } + def next_page_token=(value) + end + + # Token to get the next page of results. + sig { void } + def clear_next_page_token + end + + # Query to filter schedules. + sig { returns(String) } + def query + end + + # Query to filter schedules. + sig { params(value: String).void } + def query=(value) + end + + # Query to filter schedules. + sig { void } + def clear_query + 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::WorkflowService::V1::ListSchedulesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListSchedulesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListSchedulesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListSchedulesRequest, 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::WorkflowService::V1::ListSchedulesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + schedules: T.nilable(T::Array[T.nilable(Temporalio::Api::Schedule::V1::ScheduleListEntry)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + schedules: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Schedule::V1::ScheduleListEntry)]) } + def schedules + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def schedules=(value) + end + + sig { void } + def clear_schedules + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListSchedulesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListSchedulesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListSchedulesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListSchedulesResponse, 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::WorkflowService::V1::CountSchedulesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { returns(String) } + def query + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { params(value: String).void } + def query=(value) + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { void } + def clear_query + 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::WorkflowService::V1::CountSchedulesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountSchedulesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountSchedulesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountSchedulesRequest, 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::WorkflowService::V1::CountSchedulesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + count: T.nilable(Integer), + groups: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::CountSchedulesResponse::AggregationGroup)]) + ).void + end + def initialize( + count: 0, + groups: [] + ) + end + + # If `query` is not grouping by any field, the count is an approximate number +# of schedules that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of schedules matching the query. + sig { returns(Integer) } + def count + end + + # If `query` is not grouping by any field, the count is an approximate number +# of schedules that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of schedules matching the query. + sig { params(value: Integer).void } + def count=(value) + end + + # If `query` is not grouping by any field, the count is an approximate number +# of schedules that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of schedules matching the query. + sig { void } + def clear_count + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::CountSchedulesResponse::AggregationGroup)]) } + def groups + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def groups=(value) + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { void } + def clear_groups + 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::WorkflowService::V1::CountSchedulesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountSchedulesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountSchedulesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountSchedulesResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +class Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(String), + add_new_build_id_in_new_default_set: T.nilable(String), + add_new_compatible_build_id: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::AddNewCompatibleVersion), + promote_set_by_build_id: T.nilable(String), + promote_build_id_within_set: T.nilable(String), + merge_sets: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::MergeSets) + ).void + end + def initialize( + namespace: "", + task_queue: "", + add_new_build_id_in_new_default_set: "", + add_new_compatible_build_id: nil, + promote_set_by_build_id: "", + promote_build_id_within_set: "", + merge_sets: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Must be set, the task queue to apply changes to. Because all workers on a given task queue +# must have the same set of workflow & activity implementations, there is no reason to specify +# a task queue type here. + sig { returns(String) } + def task_queue + end + + # Must be set, the task queue to apply changes to. Because all workers on a given task queue +# must have the same set of workflow & activity implementations, there is no reason to specify +# a task queue type here. + sig { params(value: String).void } + def task_queue=(value) + end + + # Must be set, the task queue to apply changes to. Because all workers on a given task queue +# must have the same set of workflow & activity implementations, there is no reason to specify +# a task queue type here. + sig { void } + def clear_task_queue + end + + # A new build id. This operation will create a new set which will be the new overall +# default version for the queue, with this id as its only member. This new set is +# incompatible with all previous sets/versions. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: In makes perfect sense here. --) + sig { returns(String) } + def add_new_build_id_in_new_default_set + end + + # A new build id. This operation will create a new set which will be the new overall +# default version for the queue, with this id as its only member. This new set is +# incompatible with all previous sets/versions. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: In makes perfect sense here. --) + sig { params(value: String).void } + def add_new_build_id_in_new_default_set=(value) + end + + # A new build id. This operation will create a new set which will be the new overall +# default version for the queue, with this id as its only member. This new set is +# incompatible with all previous sets/versions. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: In makes perfect sense here. --) + sig { void } + def clear_add_new_build_id_in_new_default_set + end + + # Adds a new id to an existing compatible set, see sub-message definition for more. + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::AddNewCompatibleVersion)) } + def add_new_compatible_build_id + end + + # Adds a new id to an existing compatible set, see sub-message definition for more. + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::AddNewCompatibleVersion)).void } + def add_new_compatible_build_id=(value) + end + + # Adds a new id to an existing compatible set, see sub-message definition for more. + sig { void } + def clear_add_new_compatible_build_id + end + + # Promote an existing set to be the current default (if it isn't already) by targeting +# an existing build id within it. This field's value is the extant build id. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: Names are hard. --) + sig { returns(String) } + def promote_set_by_build_id + end + + # Promote an existing set to be the current default (if it isn't already) by targeting +# an existing build id within it. This field's value is the extant build id. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: Names are hard. --) + sig { params(value: String).void } + def promote_set_by_build_id=(value) + end + + # Promote an existing set to be the current default (if it isn't already) by targeting +# an existing build id within it. This field's value is the extant build id. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: Names are hard. --) + sig { void } + def clear_promote_set_by_build_id + end + + # Promote an existing build id within some set to be the current default for that set. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: Within makes perfect sense here. --) + sig { returns(String) } + def promote_build_id_within_set + end + + # Promote an existing build id within some set to be the current default for that set. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: Within makes perfect sense here. --) + sig { params(value: String).void } + def promote_build_id_within_set=(value) + end + + # Promote an existing build id within some set to be the current default for that set. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: Within makes perfect sense here. --) + sig { void } + def clear_promote_build_id_within_set + end + + # Merge two existing sets together, thus declaring all build IDs in both sets compatible +# with one another. The primary set's default will become the default for the merged set. +# This is useful if you've accidentally declared a new ID as incompatible you meant to +# declare as compatible. The unusual case of incomplete replication during failover could +# also result in a split set, which this operation can repair. + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::MergeSets)) } + def merge_sets + end + + # Merge two existing sets together, thus declaring all build IDs in both sets compatible +# with one another. The primary set's default will become the default for the merged set. +# This is useful if you've accidentally declared a new ID as incompatible you meant to +# declare as compatible. The unusual case of incomplete replication during failover could +# also result in a split set, which this operation can repair. + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::MergeSets)).void } + def merge_sets=(value) + end + + # Merge two existing sets together, thus declaring all build IDs in both sets compatible +# with one another. The primary set's default will become the default for the merged set. +# This is useful if you've accidentally declared a new ID as incompatible you meant to +# declare as compatible. The unusual case of incomplete replication during failover could +# also result in a split set, which this operation can repair. + sig { void } + def clear_merge_sets + end + + sig { returns(T.nilable(Symbol)) } + def operation + 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::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +class Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +class Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(String), + max_sets: T.nilable(Integer) + ).void + end + def initialize( + namespace: "", + task_queue: "", + max_sets: 0 + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Must be set, the task queue to interrogate about worker id compatibility. + sig { returns(String) } + def task_queue + end + + # Must be set, the task queue to interrogate about worker id compatibility. + sig { params(value: String).void } + def task_queue=(value) + end + + # Must be set, the task queue to interrogate about worker id compatibility. + sig { void } + def clear_task_queue + end + + # Limits how many compatible sets will be returned. Specify 1 to only return the current +# default major version set. 0 returns all sets. + sig { returns(Integer) } + def max_sets + end + + # Limits how many compatible sets will be returned. Specify 1 to only return the current +# default major version set. 0 returns all sets. + sig { params(value: Integer).void } + def max_sets=(value) + end + + # Limits how many compatible sets will be returned. Specify 1 to only return the current +# default major version set. 0 returns all sets. + sig { void } + def clear_max_sets + 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::WorkflowService::V1::GetWorkerBuildIdCompatibilityRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +class Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + major_version_sets: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::CompatibleVersionSet)]) + ).void + end + def initialize( + major_version_sets: [] + ) + end + + # Major version sets, in order from oldest to newest. The last element of the list will always +# be the current default major version. IE: New workflows will target the most recent version +# in that version set. +# +# There may be fewer sets returned than exist, if the request chose to limit this response. + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::CompatibleVersionSet)]) } + def major_version_sets + end + + # Major version sets, in order from oldest to newest. The last element of the list will always +# be the current default major version. IE: New workflows will target the most recent version +# in that version set. +# +# There may be fewer sets returned than exist, if the request chose to limit this response. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def major_version_sets=(value) + end + + # Major version sets, in order from oldest to newest. The last element of the list will always +# be the current default major version. IE: New workflows will target the most recent version +# in that version set. +# +# There may be fewer sets returned than exist, if the request chose to limit this response. + sig { void } + def clear_major_version_sets + 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::WorkflowService::V1::GetWorkerBuildIdCompatibilityResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# (-- api-linter: core::0134::request-mask-required=disabled +# aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --) +# (-- api-linter: core::0134::request-resource-required=disabled +# aip.dev/not-precedent: GetWorkerBuildIdCompatibilityRequest RPC doesn't follow Google API format. --) +# [cleanup-wv-pre-release] +class Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(String), + conflict_token: T.nilable(String), + insert_assignment_rule: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::InsertBuildIdAssignmentRule), + replace_assignment_rule: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceBuildIdAssignmentRule), + delete_assignment_rule: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteBuildIdAssignmentRule), + add_compatible_redirect_rule: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::AddCompatibleBuildIdRedirectRule), + replace_compatible_redirect_rule: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceCompatibleBuildIdRedirectRule), + delete_compatible_redirect_rule: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteCompatibleBuildIdRedirectRule), + commit_build_id: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::CommitBuildId) + ).void + end + def initialize( + namespace: "", + task_queue: "", + conflict_token: "", + insert_assignment_rule: nil, + replace_assignment_rule: nil, + delete_assignment_rule: nil, + add_compatible_redirect_rule: nil, + replace_compatible_redirect_rule: nil, + delete_compatible_redirect_rule: nil, + commit_build_id: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + 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 + + # A valid conflict_token can be taken from the previous +# ListWorkerVersioningRulesResponse or UpdateWorkerVersioningRulesResponse. +# An invalid token will cause this request to fail, ensuring that if the rules +# for this Task Queue have been modified between the previous and current +# operation, the request will fail instead of causing an unpredictable mutation. + sig { returns(String) } + def conflict_token + end + + # A valid conflict_token can be taken from the previous +# ListWorkerVersioningRulesResponse or UpdateWorkerVersioningRulesResponse. +# An invalid token will cause this request to fail, ensuring that if the rules +# for this Task Queue have been modified between the previous and current +# operation, the request will fail instead of causing an unpredictable mutation. + sig { params(value: String).void } + def conflict_token=(value) + end + + # A valid conflict_token can be taken from the previous +# ListWorkerVersioningRulesResponse or UpdateWorkerVersioningRulesResponse. +# An invalid token will cause this request to fail, ensuring that if the rules +# for this Task Queue have been modified between the previous and current +# operation, the request will fail instead of causing an unpredictable mutation. + sig { void } + def clear_conflict_token + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::InsertBuildIdAssignmentRule)) } + def insert_assignment_rule + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::InsertBuildIdAssignmentRule)).void } + def insert_assignment_rule=(value) + end + + sig { void } + def clear_insert_assignment_rule + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceBuildIdAssignmentRule)) } + def replace_assignment_rule + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceBuildIdAssignmentRule)).void } + def replace_assignment_rule=(value) + end + + sig { void } + def clear_replace_assignment_rule + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteBuildIdAssignmentRule)) } + def delete_assignment_rule + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteBuildIdAssignmentRule)).void } + def delete_assignment_rule=(value) + end + + sig { void } + def clear_delete_assignment_rule + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::AddCompatibleBuildIdRedirectRule)) } + def add_compatible_redirect_rule + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::AddCompatibleBuildIdRedirectRule)).void } + def add_compatible_redirect_rule=(value) + end + + sig { void } + def clear_add_compatible_redirect_rule + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceCompatibleBuildIdRedirectRule)) } + def replace_compatible_redirect_rule + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceCompatibleBuildIdRedirectRule)).void } + def replace_compatible_redirect_rule=(value) + end + + sig { void } + def clear_replace_compatible_redirect_rule + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteCompatibleBuildIdRedirectRule)) } + def delete_compatible_redirect_rule + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteCompatibleBuildIdRedirectRule)).void } + def delete_compatible_redirect_rule=(value) + end + + sig { void } + def clear_delete_compatible_redirect_rule + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::CommitBuildId)) } + def commit_build_id + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::CommitBuildId)).void } + def commit_build_id=(value) + end + + sig { void } + def clear_commit_build_id + end + + sig { returns(T.nilable(Symbol)) } + def operation + 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +class Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + assignment_rules: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TimestampedBuildIdAssignmentRule)]), + compatible_redirect_rules: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule)]), + conflict_token: T.nilable(String) + ).void + end + def initialize( + assignment_rules: [], + compatible_redirect_rules: [], + conflict_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TimestampedBuildIdAssignmentRule)]) } + def assignment_rules + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def assignment_rules=(value) + end + + sig { void } + def clear_assignment_rules + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule)]) } + def compatible_redirect_rules + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def compatible_redirect_rules=(value) + end + + sig { void } + def clear_compatible_redirect_rules + end + + # This value can be passed back to UpdateWorkerVersioningRulesRequest to +# ensure that the rules were not modified between the two updates, which +# could lead to lost updates and other confusion. + sig { returns(String) } + def conflict_token + end + + # This value can be passed back to UpdateWorkerVersioningRulesRequest to +# ensure that the rules were not modified between the two updates, which +# could lead to lost updates and other confusion. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This value can be passed back to UpdateWorkerVersioningRulesRequest to +# ensure that the rules were not modified between the two updates, which +# could lead to lost updates and other confusion. + sig { void } + def clear_conflict_token + 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::WorkflowService::V1::UpdateWorkerVersioningRulesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +class Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(String) + ).void + end + def initialize( + namespace: "", + task_queue: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + 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 + + 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::WorkflowService::V1::GetWorkerVersioningRulesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +class Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + assignment_rules: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TimestampedBuildIdAssignmentRule)]), + compatible_redirect_rules: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule)]), + conflict_token: T.nilable(String) + ).void + end + def initialize( + assignment_rules: [], + compatible_redirect_rules: [], + conflict_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TimestampedBuildIdAssignmentRule)]) } + def assignment_rules + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def assignment_rules=(value) + end + + sig { void } + def clear_assignment_rules + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::TimestampedCompatibleBuildIdRedirectRule)]) } + def compatible_redirect_rules + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def compatible_redirect_rules=(value) + end + + sig { void } + def clear_compatible_redirect_rules + end + + # This value can be passed back to UpdateWorkerVersioningRulesRequest to +# ensure that the rules were not modified between this List and the Update, +# which could lead to lost updates and other confusion. + sig { returns(String) } + def conflict_token + end + + # This value can be passed back to UpdateWorkerVersioningRulesRequest to +# ensure that the rules were not modified between this List and the Update, +# which could lead to lost updates and other confusion. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This value can be passed back to UpdateWorkerVersioningRulesRequest to +# ensure that the rules were not modified between this List and the Update, +# which could lead to lost updates and other confusion. + sig { void } + def clear_conflict_token + 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::WorkflowService::V1::GetWorkerVersioningRulesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +# Deprecated. Use `DescribeTaskQueue`. +class Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + build_ids: T.nilable(T::Array[String]), + task_queues: T.nilable(T::Array[String]), + reachability: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + namespace: "", + build_ids: [], + task_queues: [], + reachability: :TASK_REACHABILITY_UNSPECIFIED + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Build ids to retrieve reachability for. An empty string will be interpreted as an unversioned worker. +# The number of build ids that can be queried in a single API call is limited. +# Open source users can adjust this limit by setting the server's dynamic config value for +# `limit.reachabilityQueryBuildIds` with the caveat that this call can strain the visibility store. + sig { returns(T::Array[String]) } + def build_ids + end + + # Build ids to retrieve reachability for. An empty string will be interpreted as an unversioned worker. +# The number of build ids that can be queried in a single API call is limited. +# Open source users can adjust this limit by setting the server's dynamic config value for +# `limit.reachabilityQueryBuildIds` with the caveat that this call can strain the visibility store. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def build_ids=(value) + end + + # Build ids to retrieve reachability for. An empty string will be interpreted as an unversioned worker. +# The number of build ids that can be queried in a single API call is limited. +# Open source users can adjust this limit by setting the server's dynamic config value for +# `limit.reachabilityQueryBuildIds` with the caveat that this call can strain the visibility store. + sig { void } + def clear_build_ids + end + + # Task queues to retrieve reachability for. Leave this empty to query for all task queues associated with given +# build ids in the namespace. +# Must specify at least one task queue if querying for an unversioned worker. +# The number of task queues that the server will fetch reachability information for is limited. +# See the `GetWorkerTaskReachabilityResponse` documentation for more information. + sig { returns(T::Array[String]) } + def task_queues + end + + # Task queues to retrieve reachability for. Leave this empty to query for all task queues associated with given +# build ids in the namespace. +# Must specify at least one task queue if querying for an unversioned worker. +# The number of task queues that the server will fetch reachability information for is limited. +# See the `GetWorkerTaskReachabilityResponse` documentation for more information. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def task_queues=(value) + end + + # Task queues to retrieve reachability for. Leave this empty to query for all task queues associated with given +# build ids in the namespace. +# Must specify at least one task queue if querying for an unversioned worker. +# The number of task queues that the server will fetch reachability information for is limited. +# See the `GetWorkerTaskReachabilityResponse` documentation for more information. + sig { void } + def clear_task_queues + end + + # Type of reachability to query for. +# `TASK_REACHABILITY_NEW_WORKFLOWS` is always returned in the response. +# Use `TASK_REACHABILITY_EXISTING_WORKFLOWS` if your application needs to respond to queries on closed workflows. +# Otherwise, use `TASK_REACHABILITY_OPEN_WORKFLOWS`. Default is `TASK_REACHABILITY_EXISTING_WORKFLOWS` if left +# unspecified. +# See the TaskReachability docstring for information about each enum variant. + sig { returns(T.any(Symbol, Integer)) } + def reachability + end + + # Type of reachability to query for. +# `TASK_REACHABILITY_NEW_WORKFLOWS` is always returned in the response. +# Use `TASK_REACHABILITY_EXISTING_WORKFLOWS` if your application needs to respond to queries on closed workflows. +# Otherwise, use `TASK_REACHABILITY_OPEN_WORKFLOWS`. Default is `TASK_REACHABILITY_EXISTING_WORKFLOWS` if left +# unspecified. +# See the TaskReachability docstring for information about each enum variant. + sig { params(value: T.any(Symbol, String, Integer)).void } + def reachability=(value) + end + + # Type of reachability to query for. +# `TASK_REACHABILITY_NEW_WORKFLOWS` is always returned in the response. +# Use `TASK_REACHABILITY_EXISTING_WORKFLOWS` if your application needs to respond to queries on closed workflows. +# Otherwise, use `TASK_REACHABILITY_OPEN_WORKFLOWS`. Default is `TASK_REACHABILITY_EXISTING_WORKFLOWS` if left +# unspecified. +# See the TaskReachability docstring for information about each enum variant. + 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::WorkflowService::V1::GetWorkerTaskReachabilityRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] +# Deprecated. Use `DescribeTaskQueue`. +class Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + build_id_reachability: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::BuildIdReachability)]) + ).void + end + def initialize( + build_id_reachability: [] + ) + end + + # Task reachability, broken down by build id and then task queue. +# When requesting a large number of task queues or all task queues associated with the given build ids in a +# namespace, all task queues will be listed in the response but some of them may not contain reachability +# information due to a server enforced limit. When reaching the limit, task queues that reachability information +# could not be retrieved for will be marked with a single TASK_REACHABILITY_UNSPECIFIED entry. The caller may issue +# another call to get the reachability for those task queues. +# +# Open source users can adjust this limit by setting the server's dynamic config value for +# `limit.reachabilityTaskQueueScan` with the caveat that this call can strain the visibility store. + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::BuildIdReachability)]) } + def build_id_reachability + end + + # Task reachability, broken down by build id and then task queue. +# When requesting a large number of task queues or all task queues associated with the given build ids in a +# namespace, all task queues will be listed in the response but some of them may not contain reachability +# information due to a server enforced limit. When reaching the limit, task queues that reachability information +# could not be retrieved for will be marked with a single TASK_REACHABILITY_UNSPECIFIED entry. The caller may issue +# another call to get the reachability for those task queues. +# +# Open source users can adjust this limit by setting the server's dynamic config value for +# `limit.reachabilityTaskQueueScan` with the caveat that this call can strain the visibility store. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def build_id_reachability=(value) + end + + # Task reachability, broken down by build id and then task queue. +# When requesting a large number of task queues or all task queues associated with the given build ids in a +# namespace, all task queues will be listed in the response but some of them may not contain reachability +# information due to a server enforced limit. When reaching the limit, task queues that reachability information +# could not be retrieved for will be marked with a single TASK_REACHABILITY_UNSPECIFIED entry. The caller may issue +# another call to get the reachability for those task queues. +# +# Open source users can adjust this limit by setting the server's dynamic config value for +# `limit.reachabilityTaskQueueScan` with the caveat that this call can strain the visibility store. + sig { void } + def clear_build_id_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::WorkflowService::V1::GetWorkerTaskReachabilityResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# (-- api-linter: core::0134=disabled +# aip.dev/not-precedent: Update RPCs don't follow Google API format. --) +class Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + first_execution_run_id: T.nilable(String), + wait_policy: T.nilable(Temporalio::Api::Update::V1::WaitPolicy), + request: T.nilable(Temporalio::Api::Update::V1::Request) + ).void + end + def initialize( + namespace: "", + workflow_execution: nil, + first_execution_run_id: "", + wait_policy: nil, + request: nil + ) + end + + # The namespace name of the target Workflow. + sig { returns(String) } + def namespace + end + + # The namespace name of the target Workflow. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace name of the target Workflow. + sig { void } + def clear_namespace + end + + # The target Workflow Id and (optionally) a specific Run Id thereof. +# (-- api-linter: core::0203::optional=disabled +# aip.dev/not-precedent: false positive triggered by the word "optional" --) + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + # The target Workflow Id and (optionally) a specific Run Id thereof. +# (-- api-linter: core::0203::optional=disabled +# aip.dev/not-precedent: false positive triggered by the word "optional" --) + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + # The target Workflow Id and (optionally) a specific Run Id thereof. +# (-- api-linter: core::0203::optional=disabled +# aip.dev/not-precedent: false positive triggered by the word "optional" --) + sig { void } + def clear_workflow_execution + end + + # If set, this call will error if the most recent (if no Run Id is set on +# `workflow_execution`), or specified (if it is) Workflow Execution is not +# part of the same execution chain as this Id. + sig { returns(String) } + def first_execution_run_id + end + + # If set, this call will error if the most recent (if no Run Id is set on +# `workflow_execution`), or specified (if it is) Workflow Execution is not +# part of the same execution chain as this Id. + sig { params(value: String).void } + def first_execution_run_id=(value) + end + + # If set, this call will error if the most recent (if no Run Id is set on +# `workflow_execution`), or specified (if it is) Workflow Execution is not +# part of the same execution chain as this Id. + sig { void } + def clear_first_execution_run_id + end + + # Specifies client's intent to wait for Update results. +# NOTE: This field works together with API call timeout which is limited by +# server timeout (maximum wait time). If server timeout is expired before +# user specified timeout, API call returns even if specified stage is not reached. +# Actual reached stage will be included in the response. + sig { returns(T.nilable(Temporalio::Api::Update::V1::WaitPolicy)) } + def wait_policy + end + + # Specifies client's intent to wait for Update results. +# NOTE: This field works together with API call timeout which is limited by +# server timeout (maximum wait time). If server timeout is expired before +# user specified timeout, API call returns even if specified stage is not reached. +# Actual reached stage will be included in the response. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::WaitPolicy)).void } + def wait_policy=(value) + end + + # Specifies client's intent to wait for Update results. +# NOTE: This field works together with API call timeout which is limited by +# server timeout (maximum wait time). If server timeout is expired before +# user specified timeout, API call returns even if specified stage is not reached. +# Actual reached stage will be included in the response. + sig { void } + def clear_wait_policy + end + + # The request information that will be delivered all the way down to the +# Workflow Execution. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Request)) } + def request + end + + # The request information that will be delivered all the way down to the +# Workflow Execution. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Request)).void } + def request=(value) + end + + # The request information that will be delivered all the way down to the +# Workflow Execution. + sig { void } + def clear_request + 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::WorkflowService::V1::UpdateWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionRequest, 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::WorkflowService::V1::UpdateWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + update_ref: T.nilable(Temporalio::Api::Update::V1::UpdateRef), + outcome: T.nilable(Temporalio::Api::Update::V1::Outcome), + stage: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + update_ref: nil, + outcome: nil, + stage: :UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED + ) + end + + # Enough information for subsequent poll calls if needed. Never null. + sig { returns(T.nilable(Temporalio::Api::Update::V1::UpdateRef)) } + def update_ref + end + + # Enough information for subsequent poll calls if needed. Never null. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::UpdateRef)).void } + def update_ref=(value) + end + + # Enough information for subsequent poll calls if needed. Never null. + sig { void } + def clear_update_ref + end + + # The outcome of the Update if and only if the Workflow Update +# has completed. If this response is being returned before the Update has +# completed then this field will not be set. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Outcome)) } + def outcome + end + + # The outcome of the Update if and only if the Workflow Update +# has completed. If this response is being returned before the Update has +# completed then this field will not be set. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Outcome)).void } + def outcome=(value) + end + + # The outcome of the Update if and only if the Workflow Update +# has completed. If this response is being returned before the Update has +# completed then this field will not be set. + sig { void } + def clear_outcome + end + + # The most advanced lifecycle stage that the Update is known to have +# reached, where lifecycle stages are ordered +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ADMITTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_COMPLETED. +# UNSPECIFIED will be returned if and only if the server's maximum wait +# time was reached before the Update reached the stage specified in the +# request WaitPolicy, and before the context deadline expired; clients may +# may then retry the call as needed. + sig { returns(T.any(Symbol, Integer)) } + def stage + end + + # The most advanced lifecycle stage that the Update is known to have +# reached, where lifecycle stages are ordered +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ADMITTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_COMPLETED. +# UNSPECIFIED will be returned if and only if the server's maximum wait +# time was reached before the Update reached the stage specified in the +# request WaitPolicy, and before the context deadline expired; clients may +# may then retry the call as needed. + sig { params(value: T.any(Symbol, String, Integer)).void } + def stage=(value) + end + + # The most advanced lifecycle stage that the Update is known to have +# reached, where lifecycle stages are ordered +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ADMITTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_COMPLETED. +# UNSPECIFIED will be returned if and only if the server's maximum wait +# time was reached before the Update reached the stage specified in the +# request WaitPolicy, and before the context deadline expired; clients may +# may then retry the call as needed. + sig { void } + def clear_stage + 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::WorkflowService::V1::UpdateWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionResponse, 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::WorkflowService::V1::StartBatchOperationRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + visibility_query: T.nilable(String), + job_id: T.nilable(String), + reason: T.nilable(String), + executions: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)]), + max_operations_per_second: T.nilable(Float), + termination_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationTermination), + signal_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationSignal), + cancellation_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationCancellation), + deletion_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationDeletion), + reset_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationReset), + update_workflow_options_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationUpdateWorkflowExecutionOptions), + unpause_activities_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationUnpauseActivities), + reset_activities_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationResetActivities), + update_activity_options_operation: T.nilable(Temporalio::Api::Batch::V1::BatchOperationUpdateActivityOptions) + ).void + end + def initialize( + namespace: "", + visibility_query: "", + job_id: "", + reason: "", + executions: [], + max_operations_per_second: 0.0, + termination_operation: nil, + signal_operation: nil, + cancellation_operation: nil, + deletion_operation: nil, + reset_operation: nil, + update_workflow_options_operation: nil, + unpause_activities_operation: nil, + reset_activities_operation: nil, + update_activity_options_operation: nil + ) + end + + # Namespace that contains the batch operation + sig { returns(String) } + def namespace + end + + # Namespace that contains the batch operation + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace that contains the batch operation + sig { void } + def clear_namespace + end + + # Visibility query defines the the group of workflow to apply the batch operation +# This field and `executions` are mutually exclusive + sig { returns(String) } + def visibility_query + end + + # Visibility query defines the the group of workflow to apply the batch operation +# This field and `executions` are mutually exclusive + sig { params(value: String).void } + def visibility_query=(value) + end + + # Visibility query defines the the group of workflow to apply the batch operation +# This field and `executions` are mutually exclusive + sig { void } + def clear_visibility_query + end + + # Job ID defines the unique ID for the batch job + sig { returns(String) } + def job_id + end + + # Job ID defines the unique ID for the batch job + sig { params(value: String).void } + def job_id=(value) + end + + # Job ID defines the unique ID for the batch job + sig { void } + def clear_job_id + end + + # Reason to perform the batch operation + sig { returns(String) } + def reason + end + + # Reason to perform the batch operation + sig { params(value: String).void } + def reason=(value) + end + + # Reason to perform the batch operation + sig { void } + def clear_reason + end + + # Executions to apply the batch operation +# This field and `visibility_query` are mutually exclusive + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)]) } + def executions + end + + # Executions to apply the batch operation +# This field and `visibility_query` are mutually exclusive + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def executions=(value) + end + + # Executions to apply the batch operation +# This field and `visibility_query` are mutually exclusive + sig { void } + def clear_executions + end + + # Limit for the number of operations processed per second within this batch. +# Its purpose is to reduce the stress on the system caused by batch operations, which helps to prevent system +# overload and minimize potential delays in executing ongoing tasks for user workers. +# Note that when no explicit limit is provided, the server will operate according to its limit defined by the +# dynamic configuration key `worker.batcherRPS`. This also applies if the value in this field exceeds the +# server's configured limit. + sig { returns(Float) } + def max_operations_per_second + end + + # Limit for the number of operations processed per second within this batch. +# Its purpose is to reduce the stress on the system caused by batch operations, which helps to prevent system +# overload and minimize potential delays in executing ongoing tasks for user workers. +# Note that when no explicit limit is provided, the server will operate according to its limit defined by the +# dynamic configuration key `worker.batcherRPS`. This also applies if the value in this field exceeds the +# server's configured limit. + sig { params(value: Float).void } + def max_operations_per_second=(value) + end + + # Limit for the number of operations processed per second within this batch. +# Its purpose is to reduce the stress on the system caused by batch operations, which helps to prevent system +# overload and minimize potential delays in executing ongoing tasks for user workers. +# Note that when no explicit limit is provided, the server will operate according to its limit defined by the +# dynamic configuration key `worker.batcherRPS`. This also applies if the value in this field exceeds the +# server's configured limit. + sig { void } + def clear_max_operations_per_second + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationTermination)) } + def termination_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationTermination)).void } + def termination_operation=(value) + end + + sig { void } + def clear_termination_operation + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationSignal)) } + def signal_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationSignal)).void } + def signal_operation=(value) + end + + sig { void } + def clear_signal_operation + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationCancellation)) } + def cancellation_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationCancellation)).void } + def cancellation_operation=(value) + end + + sig { void } + def clear_cancellation_operation + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationDeletion)) } + def deletion_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationDeletion)).void } + def deletion_operation=(value) + end + + sig { void } + def clear_deletion_operation + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationReset)) } + def reset_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationReset)).void } + def reset_operation=(value) + end + + sig { void } + def clear_reset_operation + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationUpdateWorkflowExecutionOptions)) } + def update_workflow_options_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationUpdateWorkflowExecutionOptions)).void } + def update_workflow_options_operation=(value) + end + + sig { void } + def clear_update_workflow_options_operation + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationUnpauseActivities)) } + def unpause_activities_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationUnpauseActivities)).void } + def unpause_activities_operation=(value) + end + + sig { void } + def clear_unpause_activities_operation + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationResetActivities)) } + def reset_activities_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationResetActivities)).void } + def reset_activities_operation=(value) + end + + sig { void } + def clear_reset_activities_operation + end + + sig { returns(T.nilable(Temporalio::Api::Batch::V1::BatchOperationUpdateActivityOptions)) } + def update_activity_options_operation + end + + sig { params(value: T.nilable(Temporalio::Api::Batch::V1::BatchOperationUpdateActivityOptions)).void } + def update_activity_options_operation=(value) + end + + sig { void } + def clear_update_activity_options_operation + end + + sig { returns(T.nilable(Symbol)) } + def operation + 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::WorkflowService::V1::StartBatchOperationRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartBatchOperationRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StartBatchOperationRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartBatchOperationRequest, 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::WorkflowService::V1::StartBatchOperationResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::StartBatchOperationResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartBatchOperationResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StartBatchOperationResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartBatchOperationResponse, 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::WorkflowService::V1::StopBatchOperationRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + job_id: T.nilable(String), + reason: T.nilable(String), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + job_id: "", + reason: "", + identity: "" + ) + end + + # Namespace that contains the batch operation + sig { returns(String) } + def namespace + end + + # Namespace that contains the batch operation + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace that contains the batch operation + sig { void } + def clear_namespace + end + + # Batch job id + sig { returns(String) } + def job_id + end + + # Batch job id + sig { params(value: String).void } + def job_id=(value) + end + + # Batch job id + sig { void } + def clear_job_id + end + + # Reason to stop a batch operation + sig { returns(String) } + def reason + end + + # Reason to stop a batch operation + sig { params(value: String).void } + def reason=(value) + end + + # Reason to stop a batch operation + sig { void } + def clear_reason + end + + # Identity of the operator + sig { returns(String) } + def identity + end + + # Identity of the operator + sig { params(value: String).void } + def identity=(value) + end + + # Identity of the operator + sig { void } + def clear_identity + 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::WorkflowService::V1::StopBatchOperationRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StopBatchOperationRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StopBatchOperationRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StopBatchOperationRequest, 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::WorkflowService::V1::StopBatchOperationResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::StopBatchOperationResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StopBatchOperationResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StopBatchOperationResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StopBatchOperationResponse, 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::WorkflowService::V1::DescribeBatchOperationRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + job_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + job_id: "" + ) + end + + # Namespace that contains the batch operation + sig { returns(String) } + def namespace + end + + # Namespace that contains the batch operation + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace that contains the batch operation + sig { void } + def clear_namespace + end + + # Batch job id + sig { returns(String) } + def job_id + end + + # Batch job id + sig { params(value: String).void } + def job_id=(value) + end + + # Batch job id + sig { void } + def clear_job_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::WorkflowService::V1::DescribeBatchOperationRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeBatchOperationRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeBatchOperationRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeBatchOperationRequest, 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::WorkflowService::V1::DescribeBatchOperationResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + operation_type: T.nilable(T.any(Symbol, String, Integer)), + job_id: T.nilable(String), + state: T.nilable(T.any(Symbol, String, Integer)), + start_time: T.nilable(Google::Protobuf::Timestamp), + close_time: T.nilable(Google::Protobuf::Timestamp), + total_operation_count: T.nilable(Integer), + complete_operation_count: T.nilable(Integer), + failure_operation_count: T.nilable(Integer), + identity: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + operation_type: :BATCH_OPERATION_TYPE_UNSPECIFIED, + job_id: "", + state: :BATCH_OPERATION_STATE_UNSPECIFIED, + start_time: nil, + close_time: nil, + total_operation_count: 0, + complete_operation_count: 0, + failure_operation_count: 0, + identity: "", + reason: "" + ) + end + + # Batch operation type + sig { returns(T.any(Symbol, Integer)) } + def operation_type + end + + # Batch operation type + sig { params(value: T.any(Symbol, String, Integer)).void } + def operation_type=(value) + end + + # Batch operation type + sig { void } + def clear_operation_type + end + + # Batch job ID + sig { returns(String) } + def job_id + end + + # Batch job ID + sig { params(value: String).void } + def job_id=(value) + end + + # Batch job ID + sig { void } + def clear_job_id + end + + # Batch operation state + sig { returns(T.any(Symbol, Integer)) } + def state + end + + # Batch operation state + sig { params(value: T.any(Symbol, String, Integer)).void } + def state=(value) + end + + # Batch operation state + sig { void } + def clear_state + end + + # Batch operation start time + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # Batch operation start time + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # Batch operation start time + sig { void } + def clear_start_time + end + + # Batch operation close time + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def close_time + end + + # Batch operation close time + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def close_time=(value) + end + + # Batch operation close time + sig { void } + def clear_close_time + end + + # Total operation count + sig { returns(Integer) } + def total_operation_count + end + + # Total operation count + sig { params(value: Integer).void } + def total_operation_count=(value) + end + + # Total operation count + sig { void } + def clear_total_operation_count + end + + # Complete operation count + sig { returns(Integer) } + def complete_operation_count + end + + # Complete operation count + sig { params(value: Integer).void } + def complete_operation_count=(value) + end + + # Complete operation count + sig { void } + def clear_complete_operation_count + end + + # Failure operation count + sig { returns(Integer) } + def failure_operation_count + end + + # Failure operation count + sig { params(value: Integer).void } + def failure_operation_count=(value) + end + + # Failure operation count + sig { void } + def clear_failure_operation_count + end + + # Identity indicates the operator identity + sig { returns(String) } + def identity + end + + # Identity indicates the operator identity + sig { params(value: String).void } + def identity=(value) + end + + # Identity indicates the operator identity + sig { void } + def clear_identity + end + + # Reason indicates the reason to stop a operation + sig { returns(String) } + def reason + end + + # Reason indicates the reason to stop a operation + sig { params(value: String).void } + def reason=(value) + end + + # Reason indicates the reason to stop a operation + sig { void } + def clear_reason + 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::WorkflowService::V1::DescribeBatchOperationResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeBatchOperationResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeBatchOperationResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeBatchOperationResponse, 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::WorkflowService::V1::ListBatchOperationsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "" + ) + end + + # Namespace that contains the batch operation + sig { returns(String) } + def namespace + end + + # Namespace that contains the batch operation + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace that contains the batch operation + sig { void } + def clear_namespace + end + + # List page size + sig { returns(Integer) } + def page_size + end + + # List page size + sig { params(value: Integer).void } + def page_size=(value) + end + + # List page size + sig { void } + def clear_page_size + end + + # Next page token + sig { returns(String) } + def next_page_token + end + + # Next page token + sig { params(value: String).void } + def next_page_token=(value) + end + + # Next page token + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListBatchOperationsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListBatchOperationsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListBatchOperationsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListBatchOperationsRequest, 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::WorkflowService::V1::ListBatchOperationsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + operation_info: T.nilable(T::Array[T.nilable(Temporalio::Api::Batch::V1::BatchOperationInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + operation_info: [], + next_page_token: "" + ) + end + + # BatchOperationInfo contains the basic info about batch operation + sig { returns(T::Array[T.nilable(Temporalio::Api::Batch::V1::BatchOperationInfo)]) } + def operation_info + end + + # BatchOperationInfo contains the basic info about batch operation + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def operation_info=(value) + end + + # BatchOperationInfo contains the basic info about batch operation + sig { void } + def clear_operation_info + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListBatchOperationsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListBatchOperationsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListBatchOperationsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListBatchOperationsResponse, 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::WorkflowService::V1::PollWorkflowExecutionUpdateRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + update_ref: T.nilable(Temporalio::Api::Update::V1::UpdateRef), + identity: T.nilable(String), + wait_policy: T.nilable(Temporalio::Api::Update::V1::WaitPolicy) + ).void + end + def initialize( + namespace: "", + update_ref: nil, + identity: "", + wait_policy: nil + ) + end + + # The namespace of the Workflow Execution to which the Update was +# originally issued. + sig { returns(String) } + def namespace + end + + # The namespace of the Workflow Execution to which the Update was +# originally issued. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace of the Workflow Execution to which the Update was +# originally issued. + sig { void } + def clear_namespace + end + + # The Update reference returned in the initial UpdateWorkflowExecutionResponse. + sig { returns(T.nilable(Temporalio::Api::Update::V1::UpdateRef)) } + def update_ref + end + + # The Update reference returned in the initial UpdateWorkflowExecutionResponse. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::UpdateRef)).void } + def update_ref=(value) + end + + # The Update reference returned in the initial UpdateWorkflowExecutionResponse. + sig { void } + def clear_update_ref + end + + # The identity of the worker/client who is polling this Update outcome. + sig { returns(String) } + def identity + end + + # The identity of the worker/client who is polling this Update outcome. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client who is polling this Update outcome. + sig { void } + def clear_identity + end + + # Specifies client's intent to wait for Update results. +# Omit to request a non-blocking poll. + sig { returns(T.nilable(Temporalio::Api::Update::V1::WaitPolicy)) } + def wait_policy + end + + # Specifies client's intent to wait for Update results. +# Omit to request a non-blocking poll. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::WaitPolicy)).void } + def wait_policy=(value) + end + + # Specifies client's intent to wait for Update results. +# Omit to request a non-blocking poll. + sig { void } + def clear_wait_policy + 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::WorkflowService::V1::PollWorkflowExecutionUpdateRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionUpdateRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionUpdateRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionUpdateRequest, 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::WorkflowService::V1::PollWorkflowExecutionUpdateResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + outcome: T.nilable(Temporalio::Api::Update::V1::Outcome), + stage: T.nilable(T.any(Symbol, String, Integer)), + update_ref: T.nilable(Temporalio::Api::Update::V1::UpdateRef) + ).void + end + def initialize( + outcome: nil, + stage: :UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED, + update_ref: nil + ) + end + + # The outcome of the update if and only if the update has completed. If +# this response is being returned before the update has completed (e.g. due +# to the specification of a wait policy that only waits on +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED) then this field will +# not be set. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Outcome)) } + def outcome + end + + # The outcome of the update if and only if the update has completed. If +# this response is being returned before the update has completed (e.g. due +# to the specification of a wait policy that only waits on +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED) then this field will +# not be set. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Outcome)).void } + def outcome=(value) + end + + # The outcome of the update if and only if the update has completed. If +# this response is being returned before the update has completed (e.g. due +# to the specification of a wait policy that only waits on +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED) then this field will +# not be set. + sig { void } + def clear_outcome + end + + # The most advanced lifecycle stage that the Update is known to have +# reached, where lifecycle stages are ordered +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ADMITTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_COMPLETED. +# UNSPECIFIED will be returned if and only if the server's maximum wait +# time was reached before the Update reached the stage specified in the +# request WaitPolicy, and before the context deadline expired; clients may +# may then retry the call as needed. + sig { returns(T.any(Symbol, Integer)) } + def stage + end + + # The most advanced lifecycle stage that the Update is known to have +# reached, where lifecycle stages are ordered +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ADMITTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_COMPLETED. +# UNSPECIFIED will be returned if and only if the server's maximum wait +# time was reached before the Update reached the stage specified in the +# request WaitPolicy, and before the context deadline expired; clients may +# may then retry the call as needed. + sig { params(value: T.any(Symbol, String, Integer)).void } + def stage=(value) + end + + # The most advanced lifecycle stage that the Update is known to have +# reached, where lifecycle stages are ordered +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_UNSPECIFIED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ADMITTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_ACCEPTED < +# UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_COMPLETED. +# UNSPECIFIED will be returned if and only if the server's maximum wait +# time was reached before the Update reached the stage specified in the +# request WaitPolicy, and before the context deadline expired; clients may +# may then retry the call as needed. + sig { void } + def clear_stage + end + + # Sufficient information to address this Update. + sig { returns(T.nilable(Temporalio::Api::Update::V1::UpdateRef)) } + def update_ref + end + + # Sufficient information to address this Update. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::UpdateRef)).void } + def update_ref=(value) + end + + # Sufficient information to address this Update. + sig { void } + def clear_update_ref + 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::WorkflowService::V1::PollWorkflowExecutionUpdateResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionUpdateResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionUpdateResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionUpdateResponse, 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::WorkflowService::V1::PollNexusTaskQueueRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + poller_group_id: T.nilable(String), + identity: T.nilable(String), + worker_instance_key: T.nilable(String), + worker_version_capabilities: T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities), + deployment_options: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions), + worker_heartbeat: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat)]) + ).void + end + def initialize( + namespace: "", + task_queue: nil, + poller_group_id: "", + identity: "", + worker_instance_key: "", + worker_version_capabilities: nil, + deployment_options: nil, + worker_heartbeat: [] + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + sig { void } + def clear_task_queue + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollNexusTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { returns(String) } + def poller_group_id + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollNexusTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { params(value: String).void } + def poller_group_id=(value) + end + + # Unless this is the first poll, the client must pass one of the poller group IDs received in +# `poller_group_infos` of the last the PollNexusTaskQueueResponse according to the +# instructions. If not set, the poll is routed randomly which can cause it being blocked +# without receiving a task while the queue actually has tasks in another server location. + sig { void } + def clear_poller_group_id + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { returns(String) } + def worker_instance_key + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # A unique key for this worker instance, used for tracking worker lifecycle. +# This is guaranteed to be unique, whereas identity is not guaranteed to be unique. + sig { void } + def clear_worker_instance_key + end + + # Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. +# Deprecated. Replaced by deployment_options. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities)) } + def worker_version_capabilities + end + + # Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. +# Deprecated. Replaced by deployment_options. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerVersionCapabilities)).void } + def worker_version_capabilities=(value) + end + + # Information about this worker's build identifier and if it is choosing to use the versioning +# feature. See the `WorkerVersionCapabilities` docstring for more. +# Deprecated. Replaced by deployment_options. + sig { void } + def clear_worker_version_capabilities + end + + # Worker deployment options that user has set in the worker. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)) } + def deployment_options + end + + # Worker deployment options that user has set in the worker. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentOptions)).void } + def deployment_options=(value) + end + + # Worker deployment options that user has set in the worker. + sig { void } + def clear_deployment_options + end + + # Worker info to be sent to the server. + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat)]) } + def worker_heartbeat + end + + # Worker info to be sent to the server. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def worker_heartbeat=(value) + end + + # Worker info to be sent to the server. + sig { void } + def clear_worker_heartbeat + 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::WorkflowService::V1::PollNexusTaskQueueRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueRequest, 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::WorkflowService::V1::PollNexusTaskQueueResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + request: T.nilable(Temporalio::Api::Nexus::V1::Request), + poller_scaling_decision: T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision), + poller_group_id: T.nilable(String), + poller_group_infos: T.nilable(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerGroupInfo)]) + ).void + end + def initialize( + task_token: "", + request: nil, + poller_scaling_decision: nil, + poller_group_id: "", + poller_group_infos: [] + ) + end + + # An opaque unique identifier for this task for correlating a completion request the embedded request. + sig { returns(String) } + def task_token + end + + # An opaque unique identifier for this task for correlating a completion request the embedded request. + sig { params(value: String).void } + def task_token=(value) + end + + # An opaque unique identifier for this task for correlating a completion request the embedded request. + sig { void } + def clear_task_token + end + + # Embedded request as translated from the incoming frontend request. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Request)) } + def request + end + + # Embedded request as translated from the incoming frontend request. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Request)).void } + def request=(value) + end + + # Embedded request as translated from the incoming frontend request. + sig { void } + def clear_request + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision)) } + def poller_scaling_decision + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::PollerScalingDecision)).void } + def poller_scaling_decision=(value) + end + + # Server-advised information the SDK may use to adjust its poller count. + sig { void } + def clear_poller_scaling_decision + end + + # This poller group ID identifies the owner of the nexus task awaiting for synchronous +# response. +# Corresponding `RespondNexusTaskCompleted` and `RespondNexusTaskFailed` calls should pass this +# value for proper response routing. + sig { returns(String) } + def poller_group_id + end + + # This poller group ID identifies the owner of the nexus task awaiting for synchronous +# response. +# Corresponding `RespondNexusTaskCompleted` and `RespondNexusTaskFailed` calls should pass this +# value for proper response routing. + sig { params(value: String).void } + def poller_group_id=(value) + end + + # This poller group ID identifies the owner of the nexus task awaiting for synchronous +# response. +# Corresponding `RespondNexusTaskCompleted` and `RespondNexusTaskFailed` calls should pass this +# value for proper response routing. + sig { void } + def clear_poller_group_id + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { returns(T::Array[T.nilable(Temporalio::Api::TaskQueue::V1::PollerGroupInfo)]) } + def poller_group_infos + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def poller_group_infos=(value) + end + + # The weighted list of poller groups IDs that client should use for future polls to this task +# queue. Client is expected to: +# 1. Maintain minimum number of pollers no less than the number of groups. +# 2. Try to assign the next poll to a group without any pending polls, +# 3. If every group has some pending polls, assign the next poll to a group randomly +# according to the weights. + sig { void } + def clear_poller_group_infos + 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::WorkflowService::V1::PollNexusTaskQueueResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueResponse, 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::WorkflowService::V1::RespondNexusTaskCompletedRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + identity: T.nilable(String), + task_token: T.nilable(String), + response: T.nilable(Temporalio::Api::Nexus::V1::Response), + poller_group_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + identity: "", + task_token: "", + response: nil, + poller_group_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this task as received via a poll response. + sig { returns(String) } + def task_token + end + + # A unique identifier for this task as received via a poll response. + sig { params(value: String).void } + def task_token=(value) + end + + # A unique identifier for this task as received via a poll response. + sig { void } + def clear_task_token + end + + # Embedded response to be translated into a frontend response. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Response)) } + def response + end + + # Embedded response to be translated into a frontend response. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Response)).void } + def response=(value) + end + + # Embedded response to be translated into a frontend response. + sig { void } + def clear_response + end + + # Client must forward the poller_group_id received in PollNexusTaskQueueResponse for proper +# routing of the response. + sig { returns(String) } + def poller_group_id + end + + # Client must forward the poller_group_id received in PollNexusTaskQueueResponse for proper +# routing of the response. + sig { params(value: String).void } + def poller_group_id=(value) + end + + # Client must forward the poller_group_id received in PollNexusTaskQueueResponse for proper +# routing of the response. + sig { void } + def clear_poller_group_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::WorkflowService::V1::RespondNexusTaskCompletedRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondNexusTaskCompletedRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondNexusTaskCompletedRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondNexusTaskCompletedRequest, 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::WorkflowService::V1::RespondNexusTaskCompletedResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RespondNexusTaskCompletedResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondNexusTaskCompletedResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondNexusTaskCompletedResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondNexusTaskCompletedResponse, 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::WorkflowService::V1::RespondNexusTaskFailedRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + identity: T.nilable(String), + task_token: T.nilable(String), + error: T.nilable(Temporalio::Api::Nexus::V1::HandlerError), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + poller_group_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + identity: "", + task_token: "", + error: nil, + failure: nil, + poller_group_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this task. + sig { returns(String) } + def task_token + end + + # A unique identifier for this task. + sig { params(value: String).void } + def task_token=(value) + end + + # A unique identifier for this task. + sig { void } + def clear_task_token + end + + # Deprecated. Use the failure field instead. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::HandlerError)) } + def error + end + + # Deprecated. Use the failure field instead. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::HandlerError)).void } + def error=(value) + end + + # Deprecated. Use the failure field instead. + sig { void } + def clear_error + end + + # The error the handler failed with. Must contain a NexusHandlerFailureInfo object. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The error the handler failed with. Must contain a NexusHandlerFailureInfo object. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The error the handler failed with. Must contain a NexusHandlerFailureInfo object. + sig { void } + def clear_failure + end + + # Client must forward the poller_group_id received in PollNexusTaskQueueResponse for proper +# routing of the response. + sig { returns(String) } + def poller_group_id + end + + # Client must forward the poller_group_id received in PollNexusTaskQueueResponse for proper +# routing of the response. + sig { params(value: String).void } + def poller_group_id=(value) + end + + # Client must forward the poller_group_id received in PollNexusTaskQueueResponse for proper +# routing of the response. + sig { void } + def clear_poller_group_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::WorkflowService::V1::RespondNexusTaskFailedRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondNexusTaskFailedRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondNexusTaskFailedRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondNexusTaskFailedRequest, 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::WorkflowService::V1::RespondNexusTaskFailedResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RespondNexusTaskFailedResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondNexusTaskFailedResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondNexusTaskFailedResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondNexusTaskFailedResponse, 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::WorkflowService::V1::ExecuteMultiOperationRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + operations: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest::Operation)]), + resource_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + operations: [], + resource_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # List of operations to execute within a single workflow. +# +# Preconditions: +# - The list of operations must not be empty. +# - The workflow ids must match across operations. +# - The only valid list of operations at this time is [StartWorkflow, UpdateWorkflow], in this order. +# +# Note that additional operation-specific restrictions have to be considered. + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest::Operation)]) } + def operations + end + + # List of operations to execute within a single workflow. +# +# Preconditions: +# - The list of operations must not be empty. +# - The workflow ids must match across operations. +# - The only valid list of operations at this time is [StartWorkflow, UpdateWorkflow], in this order. +# +# Note that additional operation-specific restrictions have to be considered. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def operations=(value) + end + + # List of operations to execute within a single workflow. +# +# Preconditions: +# - The list of operations must not be empty. +# - The workflow ids must match across operations. +# - The only valid list of operations at this time is [StartWorkflow, UpdateWorkflow], in this order. +# +# Note that additional operation-specific restrictions have to be considered. + sig { void } + def clear_operations + end + + # Resource ID for routing. Should match operations[0].start_workflow.workflow_id + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Should match operations[0].start_workflow.workflow_id + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Should match operations[0].start_workflow.workflow_id + sig { void } + def clear_resource_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::WorkflowService::V1::ExecuteMultiOperationRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# IMPORTANT: For [StartWorkflow, UpdateWorkflow] combination ("Update-with-Start") when both +# 1. the workflow update for the requested update ID has already completed, and +# 2. the workflow for the requested workflow ID has already been closed, +# then you'll receive +# - an update response containing the update's outcome, and +# - a start response with a `status` field that reflects the workflow's current state. +class Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + responses: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse::Response)]) + ).void + end + def initialize( + responses: [] + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse::Response)]) } + def responses + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def responses=(value) + end + + sig { void } + def clear_responses + 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::WorkflowService::V1::ExecuteMultiOperationResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# NOTE: keep in sync with temporal.api.batch.v1.BatchOperationUpdateActivityOptions +class Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + identity: T.nilable(String), + activity_options: T.nilable(Temporalio::Api::Activity::V1::ActivityOptions), + update_mask: T.nilable(Google::Protobuf::FieldMask), + id: T.nilable(String), + type: T.nilable(String), + match_all: T.nilable(T::Boolean), + restore_original: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace: "", + execution: nil, + identity: "", + activity_options: nil, + update_mask: nil, + id: "", + type: "", + match_all: false, + restore_original: false + ) + end + + # Namespace of the workflow which scheduled this activity + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which scheduled this activity + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which scheduled this activity + sig { void } + def clear_namespace + end + + # Execution info of the workflow which scheduled this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + # Execution info of the workflow which scheduled this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + # Execution info of the workflow which scheduled this activity + sig { void } + def clear_execution + end + + # The identity of the client who initiated this request + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request + sig { void } + def clear_identity + end + + # Activity options. Partial updates are accepted and controlled by update_mask + sig { returns(T.nilable(Temporalio::Api::Activity::V1::ActivityOptions)) } + def activity_options + end + + # Activity options. Partial updates are accepted and controlled by update_mask + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::ActivityOptions)).void } + def activity_options=(value) + end + + # Activity options. Partial updates are accepted and controlled by update_mask + sig { void } + def clear_activity_options + end + + # Controls which fields from `activity_options` will be applied + sig { returns(T.nilable(Google::Protobuf::FieldMask)) } + def update_mask + end + + # Controls which fields from `activity_options` will be applied + sig { params(value: T.nilable(Google::Protobuf::FieldMask)).void } + def update_mask=(value) + end + + # Controls which fields from `activity_options` will be applied + sig { void } + def clear_update_mask + end + + # Only activity with this ID will be updated. + sig { returns(String) } + def id + end + + # Only activity with this ID will be updated. + sig { params(value: String).void } + def id=(value) + end + + # Only activity with this ID will be updated. + sig { void } + def clear_id + end + + # Update all running activities of this type. + sig { returns(String) } + def type + end + + # Update all running activities of this type. + sig { params(value: String).void } + def type=(value) + end + + # Update all running activities of this type. + sig { void } + def clear_type + end + + # Update all running activities. + sig { returns(T::Boolean) } + def match_all + end + + # Update all running activities. + sig { params(value: T::Boolean).void } + def match_all=(value) + end + + # Update all running activities. + sig { void } + def clear_match_all + end + + # If set, the activity options will be restored to the default. +# Default options are then options activity was created with. +# They are part of the first SCHEDULE event. +# This flag cannot be combined with any other option; if you supply +# restore_original together with other options, the request will be rejected. + sig { returns(T::Boolean) } + def restore_original + end + + # If set, the activity options will be restored to the default. +# Default options are then options activity was created with. +# They are part of the first SCHEDULE event. +# This flag cannot be combined with any other option; if you supply +# restore_original together with other options, the request will be rejected. + sig { params(value: T::Boolean).void } + def restore_original=(value) + end + + # If set, the activity options will be restored to the default. +# Default options are then options activity was created with. +# They are part of the first SCHEDULE event. +# This flag cannot be combined with any other option; if you supply +# restore_original together with other options, the request will be rejected. + sig { void } + def clear_restore_original + end + + sig { returns(T.nilable(Symbol)) } + def activity + 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::WorkflowService::V1::UpdateActivityOptionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsRequest, 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::WorkflowService::V1::UpdateActivityOptionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_options: T.nilable(Temporalio::Api::Activity::V1::ActivityOptions) + ).void + end + def initialize( + activity_options: nil + ) + end + + # Activity options after an update + sig { returns(T.nilable(Temporalio::Api::Activity::V1::ActivityOptions)) } + def activity_options + end + + # Activity options after an update + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::ActivityOptions)).void } + def activity_options=(value) + end + + # Activity options after an update + sig { void } + def clear_activity_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::WorkflowService::V1::UpdateActivityOptionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsResponse, 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::WorkflowService::V1::PauseActivityRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + identity: T.nilable(String), + id: T.nilable(String), + type: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + namespace: "", + execution: nil, + identity: "", + id: "", + type: "", + reason: "" + ) + end + + # Namespace of the workflow which scheduled this activity. + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which scheduled this activity. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which scheduled this activity. + sig { void } + def clear_namespace + end + + # Execution info of the workflow which scheduled this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + # Execution info of the workflow which scheduled this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + # Execution info of the workflow which scheduled this activity + sig { void } + def clear_execution + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Only the activity with this ID will be paused. + sig { returns(String) } + def id + end + + # Only the activity with this ID will be paused. + sig { params(value: String).void } + def id=(value) + end + + # Only the activity with this ID will be paused. + sig { void } + def clear_id + end + + # Pause all running activities of this type. +# Note: Experimental - the behavior of pause by activity type might change in a future release. + sig { returns(String) } + def type + end + + # Pause all running activities of this type. +# Note: Experimental - the behavior of pause by activity type might change in a future release. + sig { params(value: String).void } + def type=(value) + end + + # Pause all running activities of this type. +# Note: Experimental - the behavior of pause by activity type might change in a future release. + sig { void } + def clear_type + end + + # Reason to pause the activity. + sig { returns(String) } + def reason + end + + # Reason to pause the activity. + sig { params(value: String).void } + def reason=(value) + end + + # Reason to pause the activity. + sig { void } + def clear_reason + end + + sig { returns(T.nilable(Symbol)) } + def activity + 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::WorkflowService::V1::PauseActivityRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PauseActivityRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PauseActivityRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PauseActivityRequest, 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::WorkflowService::V1::PauseActivityResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::PauseActivityResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PauseActivityResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PauseActivityResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PauseActivityResponse, 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::WorkflowService::V1::UnpauseActivityRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + identity: T.nilable(String), + id: T.nilable(String), + type: T.nilable(String), + unpause_all: T.nilable(T::Boolean), + reset_attempts: T.nilable(T::Boolean), + reset_heartbeat: T.nilable(T::Boolean), + jitter: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + namespace: "", + execution: nil, + identity: "", + id: "", + type: "", + unpause_all: false, + reset_attempts: false, + reset_heartbeat: false, + jitter: nil + ) + end + + # Namespace of the workflow which scheduled this activity. + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which scheduled this activity. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which scheduled this activity. + sig { void } + def clear_namespace + end + + # Execution info of the workflow which scheduled this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + # Execution info of the workflow which scheduled this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + # Execution info of the workflow which scheduled this activity + sig { void } + def clear_execution + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Only the activity with this ID will be unpaused. + sig { returns(String) } + def id + end + + # Only the activity with this ID will be unpaused. + sig { params(value: String).void } + def id=(value) + end + + # Only the activity with this ID will be unpaused. + sig { void } + def clear_id + end + + # Unpause all running activities with of this type. + sig { returns(String) } + def type + end + + # Unpause all running activities with of this type. + sig { params(value: String).void } + def type=(value) + end + + # Unpause all running activities with of this type. + sig { void } + def clear_type + end + + # Unpause all running activities. + sig { returns(T::Boolean) } + def unpause_all + end + + # Unpause all running activities. + sig { params(value: T::Boolean).void } + def unpause_all=(value) + end + + # Unpause all running activities. + sig { void } + def clear_unpause_all + end + + # Providing this flag will also reset the number of attempts. + sig { returns(T::Boolean) } + def reset_attempts + end + + # Providing this flag will also reset the number of attempts. + sig { params(value: T::Boolean).void } + def reset_attempts=(value) + end + + # Providing this flag will also reset the number of attempts. + sig { void } + def clear_reset_attempts + end + + # Providing this flag will also reset the heartbeat details. + sig { returns(T::Boolean) } + def reset_heartbeat + end + + # Providing this flag will also reset the heartbeat details. + sig { params(value: T::Boolean).void } + def reset_heartbeat=(value) + end + + # Providing this flag will also reset the heartbeat details. + sig { void } + def clear_reset_heartbeat + end + + # If set, the activity will start at a random time within the specified jitter duration. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def jitter + end + + # If set, the activity will start at a random time within the specified jitter duration. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def jitter=(value) + end + + # If set, the activity will start at a random time within the specified jitter duration. + sig { void } + def clear_jitter + end + + sig { returns(T.nilable(Symbol)) } + def activity + 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::WorkflowService::V1::UnpauseActivityRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UnpauseActivityRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UnpauseActivityRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UnpauseActivityRequest, 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::WorkflowService::V1::UnpauseActivityResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::UnpauseActivityResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UnpauseActivityResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UnpauseActivityResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UnpauseActivityResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# NOTE: keep in sync with temporal.api.batch.v1.BatchOperationResetActivities +class Temporalio::Api::WorkflowService::V1::ResetActivityRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + identity: T.nilable(String), + id: T.nilable(String), + type: T.nilable(String), + match_all: T.nilable(T::Boolean), + reset_heartbeat: T.nilable(T::Boolean), + keep_paused: T.nilable(T::Boolean), + jitter: T.nilable(Google::Protobuf::Duration), + restore_original_options: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace: "", + execution: nil, + identity: "", + id: "", + type: "", + match_all: false, + reset_heartbeat: false, + keep_paused: false, + jitter: nil, + restore_original_options: false + ) + end + + # Namespace of the workflow which scheduled this activity. + sig { returns(String) } + def namespace + end + + # Namespace of the workflow which scheduled this activity. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow which scheduled this activity. + sig { void } + def clear_namespace + end + + # Execution info of the workflow which scheduled this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + # Execution info of the workflow which scheduled this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + # Execution info of the workflow which scheduled this activity + sig { void } + def clear_execution + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Only activity with this ID will be reset. + sig { returns(String) } + def id + end + + # Only activity with this ID will be reset. + sig { params(value: String).void } + def id=(value) + end + + # Only activity with this ID will be reset. + sig { void } + def clear_id + end + + # Reset all running activities with of this type. + sig { returns(String) } + def type + end + + # Reset all running activities with of this type. + sig { params(value: String).void } + def type=(value) + end + + # Reset all running activities with of this type. + sig { void } + def clear_type + end + + # Reset all running activities. + sig { returns(T::Boolean) } + def match_all + end + + # Reset all running activities. + sig { params(value: T::Boolean).void } + def match_all=(value) + end + + # Reset all running activities. + sig { void } + def clear_match_all + end + + # Indicates that activity should reset heartbeat details. +# This flag will be applied only to the new instance of the activity. + sig { returns(T::Boolean) } + def reset_heartbeat + end + + # Indicates that activity should reset heartbeat details. +# This flag will be applied only to the new instance of the activity. + sig { params(value: T::Boolean).void } + def reset_heartbeat=(value) + end + + # Indicates that activity should reset heartbeat details. +# This flag will be applied only to the new instance of the activity. + sig { void } + def clear_reset_heartbeat + end + + # If activity is paused, it will remain paused after reset + sig { returns(T::Boolean) } + def keep_paused + end + + # If activity is paused, it will remain paused after reset + sig { params(value: T::Boolean).void } + def keep_paused=(value) + end + + # If activity is paused, it will remain paused after reset + sig { void } + def clear_keep_paused + end + + # If set, and activity is in backoff, the activity will start at a random time within the specified jitter duration. +# (unless it is paused and keep_paused is set) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def jitter + end + + # If set, and activity is in backoff, the activity will start at a random time within the specified jitter duration. +# (unless it is paused and keep_paused is set) + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def jitter=(value) + end + + # If set, and activity is in backoff, the activity will start at a random time within the specified jitter duration. +# (unless it is paused and keep_paused is set) + sig { void } + def clear_jitter + end + + # If set, the activity options will be restored to the defaults. +# Default options are then options activity was created with. +# They are part of the first SCHEDULE event. + sig { returns(T::Boolean) } + def restore_original_options + end + + # If set, the activity options will be restored to the defaults. +# Default options are then options activity was created with. +# They are part of the first SCHEDULE event. + sig { params(value: T::Boolean).void } + def restore_original_options=(value) + end + + # If set, the activity options will be restored to the defaults. +# Default options are then options activity was created with. +# They are part of the first SCHEDULE event. + sig { void } + def clear_restore_original_options + end + + sig { returns(T.nilable(Symbol)) } + def activity + 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::WorkflowService::V1::ResetActivityRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetActivityRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ResetActivityRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetActivityRequest, 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::WorkflowService::V1::ResetActivityResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::ResetActivityResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetActivityResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ResetActivityResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ResetActivityResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Keep the parameters in sync with: +# - temporal.api.batch.v1.BatchOperationUpdateWorkflowExecutionOptions. +# - temporal.api.workflow.v1.PostResetOperation.UpdateWorkflowOptions. +class Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + workflow_execution_options: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions), + update_mask: T.nilable(Google::Protobuf::FieldMask), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_execution: nil, + workflow_execution_options: nil, + update_mask: nil, + identity: "" + ) + end + + # The namespace name of the target Workflow. + sig { returns(String) } + def namespace + end + + # The namespace name of the target Workflow. + sig { params(value: String).void } + def namespace=(value) + end + + # The namespace name of the target Workflow. + sig { void } + def clear_namespace + end + + # The target Workflow Id and (optionally) a specific Run Id thereof. +# (-- api-linter: core::0203::optional=disabled +# aip.dev/not-precedent: false positive triggered by the word "optional" --) + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + # The target Workflow Id and (optionally) a specific Run Id thereof. +# (-- api-linter: core::0203::optional=disabled +# aip.dev/not-precedent: false positive triggered by the word "optional" --) + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + # The target Workflow Id and (optionally) a specific Run Id thereof. +# (-- api-linter: core::0203::optional=disabled +# aip.dev/not-precedent: false positive triggered by the word "optional" --) + sig { void } + def clear_workflow_execution + end + + # Workflow Execution options. Partial updates are accepted and controlled by update_mask. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions)) } + def workflow_execution_options + end + + # Workflow Execution options. Partial updates are accepted and controlled by update_mask. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions)).void } + def workflow_execution_options=(value) + end + + # Workflow Execution options. Partial updates are accepted and controlled by update_mask. + sig { void } + def clear_workflow_execution_options + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { returns(T.nilable(Google::Protobuf::FieldMask)) } + def update_mask + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { params(value: T.nilable(Google::Protobuf::FieldMask)).void } + def update_mask=(value) + end + + # Controls which fields from `workflow_execution_options` will be applied. +# To unset a field, set it to null and use the update mask to indicate that it should be mutated. + sig { void } + def clear_update_mask + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + 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::WorkflowService::V1::UpdateWorkflowExecutionOptionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsRequest, 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::WorkflowService::V1::UpdateWorkflowExecutionOptionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_execution_options: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions) + ).void + end + def initialize( + workflow_execution_options: nil + ) + end + + # Workflow Execution options after update. + sig { returns(T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions)) } + def workflow_execution_options + end + + # Workflow Execution options after update. + sig { params(value: T.nilable(Temporalio::Api::Workflow::V1::WorkflowExecutionOptions)).void } + def workflow_execution_options=(value) + end + + # Workflow Execution options after update. + sig { void } + def clear_workflow_execution_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::WorkflowService::V1::UpdateWorkflowExecutionOptionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::DescribeDeploymentRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment) + ).void + end + def initialize( + namespace: "", + deployment: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + sig { void } + def clear_deployment + 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::WorkflowService::V1::DescribeDeploymentRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeDeploymentRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeDeploymentRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeDeploymentRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::DescribeDeploymentResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deployment_info: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo) + ).void + end + def initialize( + deployment_info: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)) } + def deployment_info + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)).void } + def deployment_info=(value) + end + + sig { void } + def clear_deployment_info + 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::WorkflowService::V1::DescribeDeploymentResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeDeploymentResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeDeploymentResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeDeploymentResponse, 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::WorkflowService::V1::DescribeWorkerDeploymentVersionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + version: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + report_task_queue_stats: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace: "", + version: "", + deployment_version: nil, + report_task_queue_stats: false + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Deprecated. Use `deployment_version`. + sig { returns(String) } + def version + end + + # Deprecated. Use `deployment_version`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `deployment_version`. + sig { void } + def clear_version + end + + # Required. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # Required. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # Required. + sig { void } + def clear_deployment_version + end + + # Report stats for task queues which have been polled by this version. + sig { returns(T::Boolean) } + def report_task_queue_stats + end + + # Report stats for task queues which have been polled by this version. + sig { params(value: T::Boolean).void } + def report_task_queue_stats=(value) + end + + # Report stats for task queues which have been polled by this version. + sig { void } + def clear_report_task_queue_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::WorkflowService::V1::DescribeWorkerDeploymentVersionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionRequest, 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::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_deployment_version_info: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo), + version_task_queues: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse::VersionTaskQueue)]) + ).void + end + def initialize( + worker_deployment_version_info: nil, + version_task_queues: [] + ) + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo)) } + def worker_deployment_version_info + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersionInfo)).void } + def worker_deployment_version_info=(value) + end + + sig { void } + def clear_worker_deployment_version_info + end + + # All the Task Queues that have ever polled from this Deployment version. + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse::VersionTaskQueue)]) } + def version_task_queues + end + + # All the Task Queues that have ever polled from this Deployment version. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def version_task_queues=(value) + end + + # All the Task Queues that have ever polled from this Deployment version. + sig { void } + def clear_version_task_queues + 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::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse, 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::WorkflowService::V1::DescribeWorkerDeploymentRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_name: T.nilable(String) + ).void + end + def initialize( + namespace: "", + deployment_name: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def deployment_name + end + + sig { params(value: String).void } + def deployment_name=(value) + end + + sig { void } + def clear_deployment_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::WorkflowService::V1::DescribeWorkerDeploymentRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentRequest, 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::WorkflowService::V1::DescribeWorkerDeploymentResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + conflict_token: T.nilable(String), + worker_deployment_info: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo) + ).void + end + def initialize( + conflict_token: "", + worker_deployment_info: nil + ) + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this read and a future write. + sig { returns(String) } + def conflict_token + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this read and a future write. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this read and a future write. + sig { void } + def clear_conflict_token + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo)) } + def worker_deployment_info + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo)).void } + def worker_deployment_info=(value) + end + + sig { void } + def clear_worker_deployment_info + 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::WorkflowService::V1::DescribeWorkerDeploymentResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::ListDeploymentsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + series_name: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "", + series_name: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + # Optional. Use to filter based on exact series name match. + sig { returns(String) } + def series_name + end + + # Optional. Use to filter based on exact series name match. + sig { params(value: String).void } + def series_name=(value) + end + + # Optional. Use to filter based on exact series name match. + sig { void } + def clear_series_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::WorkflowService::V1::ListDeploymentsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListDeploymentsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListDeploymentsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListDeploymentsRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::ListDeploymentsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + next_page_token: T.nilable(String), + deployments: T.nilable(T::Array[T.nilable(Temporalio::Api::Deployment::V1::DeploymentListInfo)]) + ).void + end + def initialize( + next_page_token: "", + deployments: [] + ) + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Deployment::V1::DeploymentListInfo)]) } + def deployments + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def deployments=(value) + end + + sig { void } + def clear_deployments + 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::WorkflowService::V1::ListDeploymentsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListDeploymentsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListDeploymentsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListDeploymentsResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment), + identity: T.nilable(String), + update_metadata: T.nilable(Temporalio::Api::Deployment::V1::UpdateDeploymentMetadata) + ).void + end + def initialize( + namespace: "", + deployment: nil, + identity: "", + update_metadata: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + sig { void } + def clear_deployment + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Optional. Use to add or remove user-defined metadata entries. Metadata entries are exposed +# when describing a deployment. It is a good place for information such as operator name, +# links to internal deployment pipelines, etc. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::UpdateDeploymentMetadata)) } + def update_metadata + end + + # Optional. Use to add or remove user-defined metadata entries. Metadata entries are exposed +# when describing a deployment. It is a good place for information such as operator name, +# links to internal deployment pipelines, etc. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::UpdateDeploymentMetadata)).void } + def update_metadata=(value) + end + + # Optional. Use to add or remove user-defined metadata entries. Metadata entries are exposed +# when describing a deployment. It is a good place for information such as operator name, +# links to internal deployment pipelines, etc. + sig { void } + def clear_update_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::WorkflowService::V1::SetCurrentDeploymentRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + current_deployment_info: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo), + previous_deployment_info: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo) + ).void + end + def initialize( + current_deployment_info: nil, + previous_deployment_info: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)) } + def current_deployment_info + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)).void } + def current_deployment_info=(value) + end + + sig { void } + def clear_current_deployment_info + end + + # Info of the deployment that was current before executing this operation. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)) } + def previous_deployment_info + end + + # Info of the deployment that was current before executing this operation. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)).void } + def previous_deployment_info=(value) + end + + # Info of the deployment that was current before executing this operation. + sig { void } + def clear_previous_deployment_info + 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::WorkflowService::V1::SetCurrentDeploymentResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Set/unset the Current Version of a Worker Deployment. +class Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_name: T.nilable(String), + version: T.nilable(String), + build_id: T.nilable(String), + conflict_token: T.nilable(String), + identity: T.nilable(String), + ignore_missing_task_queues: T.nilable(T::Boolean), + allow_no_pollers: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace: "", + deployment_name: "", + version: "", + build_id: "", + conflict_token: "", + identity: "", + ignore_missing_task_queues: false, + allow_no_pollers: false + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def deployment_name + end + + sig { params(value: String).void } + def deployment_name=(value) + end + + sig { void } + def clear_deployment_name + end + + # Deprecated. Use `build_id`. + sig { returns(String) } + def version + end + + # Deprecated. Use `build_id`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `build_id`. + sig { void } + def clear_version + end + + # The build id of the Version that you want to set as Current. +# Pass an empty value to set the Current Version to nil. +# A nil Current Version represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.) + sig { returns(String) } + def build_id + end + + # The build id of the Version that you want to set as Current. +# Pass an empty value to set the Current Version to nil. +# A nil Current Version represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.) + sig { params(value: String).void } + def build_id=(value) + end + + # The build id of the Version that you want to set as Current. +# Pass an empty value to set the Current Version to nil. +# A nil Current Version represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.) + sig { void } + def clear_build_id + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { returns(String) } + def conflict_token + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { params(value: String).void } + def conflict_token=(value) + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { void } + def clear_conflict_token + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Optional. By default this request would be rejected if not all the expected Task Queues are +# being polled by the new Version, to protect against accidental removal of Task Queues, or +# worker health issues. Pass `true` here to bypass this protection. +# The set of expected Task Queues is the set of all the Task Queues that were ever poller by +# the existing Current Version of the Deployment, with the following exclusions: +# - Task Queues that are not used anymore (inferred by having empty backlog and a task +# add_rate of 0.) +# - Task Queues that are moved to another Worker Deployment (inferred by the Task Queue +# having a different Current Version than the Current Version of this deployment.) +# WARNING: Do not set this flag unless you are sure that the missing task queue pollers are not +# needed. If the request is unexpectedly rejected due to missing pollers, then that means the +# pollers have not reached to the server yet. Only set this if you expect those pollers to +# never arrive. + sig { returns(T::Boolean) } + def ignore_missing_task_queues + end + + # Optional. By default this request would be rejected if not all the expected Task Queues are +# being polled by the new Version, to protect against accidental removal of Task Queues, or +# worker health issues. Pass `true` here to bypass this protection. +# The set of expected Task Queues is the set of all the Task Queues that were ever poller by +# the existing Current Version of the Deployment, with the following exclusions: +# - Task Queues that are not used anymore (inferred by having empty backlog and a task +# add_rate of 0.) +# - Task Queues that are moved to another Worker Deployment (inferred by the Task Queue +# having a different Current Version than the Current Version of this deployment.) +# WARNING: Do not set this flag unless you are sure that the missing task queue pollers are not +# needed. If the request is unexpectedly rejected due to missing pollers, then that means the +# pollers have not reached to the server yet. Only set this if you expect those pollers to +# never arrive. + sig { params(value: T::Boolean).void } + def ignore_missing_task_queues=(value) + end + + # Optional. By default this request would be rejected if not all the expected Task Queues are +# being polled by the new Version, to protect against accidental removal of Task Queues, or +# worker health issues. Pass `true` here to bypass this protection. +# The set of expected Task Queues is the set of all the Task Queues that were ever poller by +# the existing Current Version of the Deployment, with the following exclusions: +# - Task Queues that are not used anymore (inferred by having empty backlog and a task +# add_rate of 0.) +# - Task Queues that are moved to another Worker Deployment (inferred by the Task Queue +# having a different Current Version than the Current Version of this deployment.) +# WARNING: Do not set this flag unless you are sure that the missing task queue pollers are not +# needed. If the request is unexpectedly rejected due to missing pollers, then that means the +# pollers have not reached to the server yet. Only set this if you expect those pollers to +# never arrive. + sig { void } + def clear_ignore_missing_task_queues + end + + # Optional. By default this request will be rejected if no pollers have been seen for the proposed +# Current Version, in order to protect users from routing tasks to pollers that do not exist, leading +# to possible timeouts. Pass `true` here to bypass this protection. + sig { returns(T::Boolean) } + def allow_no_pollers + end + + # Optional. By default this request will be rejected if no pollers have been seen for the proposed +# Current Version, in order to protect users from routing tasks to pollers that do not exist, leading +# to possible timeouts. Pass `true` here to bypass this protection. + sig { params(value: T::Boolean).void } + def allow_no_pollers=(value) + end + + # Optional. By default this request will be rejected if no pollers have been seen for the proposed +# Current Version, in order to protect users from routing tasks to pollers that do not exist, leading +# to possible timeouts. Pass `true` here to bypass this protection. + sig { void } + def clear_allow_no_pollers + 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::WorkflowService::V1::SetWorkerDeploymentCurrentVersionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionRequest, 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::WorkflowService::V1::SetWorkerDeploymentCurrentVersionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + conflict_token: T.nilable(String), + previous_version: T.nilable(String), + previous_deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion) + ).void + end + def initialize( + conflict_token: "", + previous_version: "", + previous_deployment_version: nil + ) + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { returns(String) } + def conflict_token + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { void } + def clear_conflict_token + end + + # Deprecated. Use `previous_deployment_version`. + sig { returns(String) } + def previous_version + end + + # Deprecated. Use `previous_deployment_version`. + sig { params(value: String).void } + def previous_version=(value) + end + + # Deprecated. Use `previous_deployment_version`. + sig { void } + def clear_previous_version + end + + # The version that was current before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Current version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def previous_deployment_version + end + + # The version that was current before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Current version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def previous_deployment_version=(value) + end + + # The version that was current before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Current version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { void } + def clear_previous_deployment_version + 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::WorkflowService::V1::SetWorkerDeploymentCurrentVersionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Set/unset the Ramping Version of a Worker Deployment and its ramp percentage. +class Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_name: T.nilable(String), + version: T.nilable(String), + build_id: T.nilable(String), + percentage: T.nilable(Float), + conflict_token: T.nilable(String), + identity: T.nilable(String), + ignore_missing_task_queues: T.nilable(T::Boolean), + allow_no_pollers: T.nilable(T::Boolean) + ).void + end + def initialize( + namespace: "", + deployment_name: "", + version: "", + build_id: "", + percentage: 0.0, + conflict_token: "", + identity: "", + ignore_missing_task_queues: false, + allow_no_pollers: false + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def deployment_name + end + + sig { params(value: String).void } + def deployment_name=(value) + end + + sig { void } + def clear_deployment_name + end + + # Deprecated. Use `build_id`. + sig { returns(String) } + def version + end + + # Deprecated. Use `build_id`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `build_id`. + sig { void } + def clear_version + end + + # The build id of the Version that you want to ramp traffic to. +# Pass an empty value to set the Ramping Version to nil. +# A nil Ramping Version represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.) + sig { returns(String) } + def build_id + end + + # The build id of the Version that you want to ramp traffic to. +# Pass an empty value to set the Ramping Version to nil. +# A nil Ramping Version represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.) + sig { params(value: String).void } + def build_id=(value) + end + + # The build id of the Version that you want to ramp traffic to. +# Pass an empty value to set the Ramping Version to nil. +# A nil Ramping Version represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.) + sig { void } + def clear_build_id + end + + # Ramp percentage to set. Valid range: [0,100]. + sig { returns(Float) } + def percentage + end + + # Ramp percentage to set. Valid range: [0,100]. + sig { params(value: Float).void } + def percentage=(value) + end + + # Ramp percentage to set. Valid range: [0,100]. + sig { void } + def clear_percentage + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { returns(String) } + def conflict_token + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { params(value: String).void } + def conflict_token=(value) + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { void } + def clear_conflict_token + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Optional. By default this request would be rejected if not all the expected Task Queues are +# being polled by the new Version, to protect against accidental removal of Task Queues, or +# worker health issues. Pass `true` here to bypass this protection. +# The set of expected Task Queues equals to all the Task Queues ever polled from the existing +# Current Version of the Deployment, with the following exclusions: +# - Task Queues that are not used anymore (inferred by having empty backlog and a task +# add_rate of 0.) +# - Task Queues that are moved to another Worker Deployment (inferred by the Task Queue +# having a different Current Version than the Current Version of this deployment.) +# WARNING: Do not set this flag unless you are sure that the missing task queue poller are not +# needed. If the request is unexpectedly rejected due to missing pollers, then that means the +# pollers have not reached to the server yet. Only set this if you expect those pollers to +# never arrive. +# Note: this check only happens when the ramping version is about to change, not every time +# that the percentage changes. Also note that the check is against the deployment's Current +# Version, not the previous Ramping Version. + sig { returns(T::Boolean) } + def ignore_missing_task_queues + end + + # Optional. By default this request would be rejected if not all the expected Task Queues are +# being polled by the new Version, to protect against accidental removal of Task Queues, or +# worker health issues. Pass `true` here to bypass this protection. +# The set of expected Task Queues equals to all the Task Queues ever polled from the existing +# Current Version of the Deployment, with the following exclusions: +# - Task Queues that are not used anymore (inferred by having empty backlog and a task +# add_rate of 0.) +# - Task Queues that are moved to another Worker Deployment (inferred by the Task Queue +# having a different Current Version than the Current Version of this deployment.) +# WARNING: Do not set this flag unless you are sure that the missing task queue poller are not +# needed. If the request is unexpectedly rejected due to missing pollers, then that means the +# pollers have not reached to the server yet. Only set this if you expect those pollers to +# never arrive. +# Note: this check only happens when the ramping version is about to change, not every time +# that the percentage changes. Also note that the check is against the deployment's Current +# Version, not the previous Ramping Version. + sig { params(value: T::Boolean).void } + def ignore_missing_task_queues=(value) + end + + # Optional. By default this request would be rejected if not all the expected Task Queues are +# being polled by the new Version, to protect against accidental removal of Task Queues, or +# worker health issues. Pass `true` here to bypass this protection. +# The set of expected Task Queues equals to all the Task Queues ever polled from the existing +# Current Version of the Deployment, with the following exclusions: +# - Task Queues that are not used anymore (inferred by having empty backlog and a task +# add_rate of 0.) +# - Task Queues that are moved to another Worker Deployment (inferred by the Task Queue +# having a different Current Version than the Current Version of this deployment.) +# WARNING: Do not set this flag unless you are sure that the missing task queue poller are not +# needed. If the request is unexpectedly rejected due to missing pollers, then that means the +# pollers have not reached to the server yet. Only set this if you expect those pollers to +# never arrive. +# Note: this check only happens when the ramping version is about to change, not every time +# that the percentage changes. Also note that the check is against the deployment's Current +# Version, not the previous Ramping Version. + sig { void } + def clear_ignore_missing_task_queues + end + + # Optional. By default this request will be rejected if no pollers have been seen for the proposed +# Current Version, in order to protect users from routing tasks to pollers that do not exist, leading +# to possible timeouts. Pass `true` here to bypass this protection. + sig { returns(T::Boolean) } + def allow_no_pollers + end + + # Optional. By default this request will be rejected if no pollers have been seen for the proposed +# Current Version, in order to protect users from routing tasks to pollers that do not exist, leading +# to possible timeouts. Pass `true` here to bypass this protection. + sig { params(value: T::Boolean).void } + def allow_no_pollers=(value) + end + + # Optional. By default this request will be rejected if no pollers have been seen for the proposed +# Current Version, in order to protect users from routing tasks to pollers that do not exist, leading +# to possible timeouts. Pass `true` here to bypass this protection. + sig { void } + def clear_allow_no_pollers + 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::WorkflowService::V1::SetWorkerDeploymentRampingVersionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionRequest, 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::WorkflowService::V1::SetWorkerDeploymentRampingVersionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + conflict_token: T.nilable(String), + previous_version: T.nilable(String), + previous_deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + previous_percentage: T.nilable(Float) + ).void + end + def initialize( + conflict_token: "", + previous_version: "", + previous_deployment_version: nil, + previous_percentage: 0.0 + ) + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { returns(String) } + def conflict_token + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { void } + def clear_conflict_token + end + + # Deprecated. Use `previous_deployment_version`. + sig { returns(String) } + def previous_version + end + + # Deprecated. Use `previous_deployment_version`. + sig { params(value: String).void } + def previous_version=(value) + end + + # Deprecated. Use `previous_deployment_version`. + sig { void } + def clear_previous_version + end + + # The version that was ramping before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Ramping version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def previous_deployment_version + end + + # The version that was ramping before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Ramping version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def previous_deployment_version=(value) + end + + # The version that was ramping before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Ramping version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { void } + def clear_previous_deployment_version + end + + # The ramping version percentage before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Ramping version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { returns(Float) } + def previous_percentage + end + + # The ramping version percentage before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Ramping version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { params(value: Float).void } + def previous_percentage=(value) + end + + # The ramping version percentage before executing this operation. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# Ramping version info before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { void } + def clear_previous_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::WorkflowService::V1::SetWorkerDeploymentRampingVersionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Creates a new WorkerDeployment. +class Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_name: T.nilable(String), + identity: T.nilable(String), + request_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + deployment_name: "", + identity: "", + request_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # The name of the Worker Deployment to create. If a Worker Deployment with +# this name already exists, an error will be returned. + sig { returns(String) } + def deployment_name + end + + # The name of the Worker Deployment to create. If a Worker Deployment with +# this name already exists, an error will be returned. + sig { params(value: String).void } + def deployment_name=(value) + end + + # The name of the Worker Deployment to create. If a Worker Deployment with +# this name already exists, an error will be returned. + sig { void } + def clear_deployment_name + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. + sig { returns(String) } + def request_id + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. + sig { void } + def clear_request_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::WorkflowService::V1::CreateWorkerDeploymentRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentRequest, 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::WorkflowService::V1::CreateWorkerDeploymentResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + conflict_token: T.nilable(String) + ).void + end + def initialize( + conflict_token: "" + ) + end + + # This value is returned so that it can be optionally passed to APIs that +# write to the WorkerDeployment state to ensure that the state did not +# change between this API call and a future write. + sig { returns(String) } + def conflict_token + end + + # This value is returned so that it can be optionally passed to APIs that +# write to the WorkerDeployment state to ensure that the state did not +# change between this API call and a future write. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This value is returned so that it can be optionally passed to APIs that +# write to the WorkerDeployment state to ensure that the state did not +# change between this API call and a future write. + sig { void } + def clear_conflict_token + 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::WorkflowService::V1::CreateWorkerDeploymentResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentResponse, 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::WorkflowService::V1::ListWorkerDeploymentsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListWorkerDeploymentsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsRequest, 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::WorkflowService::V1::ListWorkerDeploymentsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + next_page_token: T.nilable(String), + worker_deployments: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse::WorkerDeploymentSummary)]) + ).void + end + def initialize( + next_page_token: "", + worker_deployments: [] + ) + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + # The list of worker deployments. + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse::WorkerDeploymentSummary)]) } + def worker_deployments + end + + # The list of worker deployments. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def worker_deployments=(value) + end + + # The list of worker deployments. + sig { void } + def clear_worker_deployments + 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::WorkflowService::V1::ListWorkerDeploymentsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Creates a new WorkerDeploymentVersion. +class Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + compute_config: T.nilable(Temporalio::Api::Compute::V1::ComputeConfig), + identity: T.nilable(String), + request_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + deployment_version: nil, + compute_config: nil, + identity: "", + request_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Required. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # Required. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # Required. + sig { void } + def clear_deployment_version + end + + # Optional. Contains the new worker compute configuration for the Worker +# Deployment. Used for worker scale management. + sig { returns(T.nilable(Temporalio::Api::Compute::V1::ComputeConfig)) } + def compute_config + end + + # Optional. Contains the new worker compute configuration for the Worker +# Deployment. Used for worker scale management. + sig { params(value: T.nilable(Temporalio::Api::Compute::V1::ComputeConfig)).void } + def compute_config=(value) + end + + # Optional. Contains the new worker compute configuration for the Worker +# Deployment. Used for worker scale management. + sig { void } + def clear_compute_config + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. +# If a second request with the same ID is recieved, it is considered a successful no-op. +# Retrying with a different request ID for the same deployment name + build ID is an error. + sig { returns(String) } + def request_id + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. +# If a second request with the same ID is recieved, it is considered a successful no-op. +# Retrying with a different request ID for the same deployment name + build ID is an error. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. +# If a second request with the same ID is recieved, it is considered a successful no-op. +# Retrying with a different request ID for the same deployment name + build ID is an error. + sig { void } + def clear_request_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::WorkflowService::V1::CreateWorkerDeploymentVersionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionRequest, 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::WorkflowService::V1::CreateWorkerDeploymentVersionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::CreateWorkerDeploymentVersionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used for manual deletion of Versions. User can delete a Version only when all the +# following conditions are met: +# - It is not the Current or Ramping Version of its Deployment. +# - It has no active pollers (none of the task queues in the Version have pollers) +# - It is not draining (see WorkerDeploymentVersionInfo.drainage_info). This condition +# can be skipped by passing `skip-drainage=true`. +class Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + version: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + skip_drainage: T.nilable(T::Boolean), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + version: "", + deployment_version: nil, + skip_drainage: false, + identity: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Deprecated. Use `deployment_version`. + sig { returns(String) } + def version + end + + # Deprecated. Use `deployment_version`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `deployment_version`. + sig { void } + def clear_version + end + + # Required. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # Required. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # Required. + sig { void } + def clear_deployment_version + end + + # Pass to force deletion even if the Version is draining. In this case the open pinned +# workflows will be stuck until manually moved to another version by UpdateWorkflowExecutionOptions. + sig { returns(T::Boolean) } + def skip_drainage + end + + # Pass to force deletion even if the Version is draining. In this case the open pinned +# workflows will be stuck until manually moved to another version by UpdateWorkflowExecutionOptions. + sig { params(value: T::Boolean).void } + def skip_drainage=(value) + end + + # Pass to force deletion even if the Version is draining. In this case the open pinned +# workflows will be stuck until manually moved to another version by UpdateWorkflowExecutionOptions. + sig { void } + def clear_skip_drainage + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + 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::WorkflowService::V1::DeleteWorkerDeploymentVersionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionRequest, 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::WorkflowService::V1::DeleteWorkerDeploymentVersionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::DeleteWorkerDeploymentVersionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Deletes records of (an old) Deployment. A deployment can only be deleted if +# it has no Version in it. +class Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_name: T.nilable(String), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + deployment_name: "", + identity: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def deployment_name + end + + sig { params(value: String).void } + def deployment_name=(value) + end + + sig { void } + def clear_deployment_name + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + 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::WorkflowService::V1::DeleteWorkerDeploymentRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentRequest, 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::WorkflowService::V1::DeleteWorkerDeploymentResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::DeleteWorkerDeploymentResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used to update the compute config of a Worker Deployment Version. +class Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + compute_config_scaling_groups: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate)]), + remove_compute_config_scaling_groups: T.nilable(T::Array[String]), + identity: T.nilable(String), + request_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + deployment_version: nil, + compute_config_scaling_groups: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate), + remove_compute_config_scaling_groups: [], + identity: "", + request_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Required. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # Required. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # Required. + sig { void } + def clear_deployment_version + end + + # Optional. Contains the compute config scaling groups to add or update for the Worker +# Deployment. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate)]) } + def compute_config_scaling_groups + end + + # Optional. Contains the compute config scaling groups to add or update for the Worker +# Deployment. + sig { params(value: ::Google::Protobuf::Map).void } + def compute_config_scaling_groups=(value) + end + + # Optional. Contains the compute config scaling groups to add or update for the Worker +# Deployment. + sig { void } + def clear_compute_config_scaling_groups + end + + # Optional. Contains the compute config scaling groups to remove from the Worker Deployment. + sig { returns(T::Array[String]) } + def remove_compute_config_scaling_groups + end + + # Optional. Contains the compute config scaling groups to remove from the Worker Deployment. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def remove_compute_config_scaling_groups=(value) + end + + # Optional. Contains the compute config scaling groups to remove from the Worker Deployment. + sig { void } + def clear_remove_compute_config_scaling_groups + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. +# If a second request with the same ID is recieved, it is considered a successful no-op. +# Retrying with a different request ID for the same deployment name + build ID is an error. + sig { returns(String) } + def request_id + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. +# If a second request with the same ID is recieved, it is considered a successful no-op. +# Retrying with a different request ID for the same deployment name + build ID is an error. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this create request for idempotence. Typically UUIDv4. +# If a second request with the same ID is recieved, it is considered a successful no-op. +# Retrying with a different request ID for the same deployment name + build ID is an error. + sig { void } + def clear_request_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::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigRequest, 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::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used to validate the compute config without attaching it to a Worker Deployment Version. +class Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + compute_config_scaling_groups: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate)]), + remove_compute_config_scaling_groups: T.nilable(T::Array[String]), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + deployment_version: nil, + compute_config_scaling_groups: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate), + remove_compute_config_scaling_groups: [], + identity: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Required. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # Required. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # Required. + sig { void } + def clear_deployment_version + end + + # Optional. Contains the compute config scaling groups to add or update for the Worker +# Deployment. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Compute::V1::ComputeConfigScalingGroupUpdate)]) } + def compute_config_scaling_groups + end + + # Optional. Contains the compute config scaling groups to add or update for the Worker +# Deployment. + sig { params(value: ::Google::Protobuf::Map).void } + def compute_config_scaling_groups=(value) + end + + # Optional. Contains the compute config scaling groups to add or update for the Worker +# Deployment. + sig { void } + def clear_compute_config_scaling_groups + end + + # Optional. Contains the compute config scaling groups to remove from the Worker Deployment. + sig { returns(T::Array[String]) } + def remove_compute_config_scaling_groups + end + + # Optional. Contains the compute config scaling groups to remove from the Worker Deployment. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def remove_compute_config_scaling_groups=(value) + end + + # Optional. Contains the compute config scaling groups to remove from the Worker Deployment. + sig { void } + def clear_remove_compute_config_scaling_groups + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + 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::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigRequest, 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::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used to update the user-defined metadata of a Worker Deployment Version. +class Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + version: T.nilable(String), + deployment_version: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion), + upsert_entries: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + remove_entries: T.nilable(T::Array[String]), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + version: "", + deployment_version: nil, + upsert_entries: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + remove_entries: [], + identity: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Deprecated. Use `deployment_version`. + sig { returns(String) } + def version + end + + # Deprecated. Use `deployment_version`. + sig { params(value: String).void } + def version=(value) + end + + # Deprecated. Use `deployment_version`. + sig { void } + def clear_version + end + + # Required. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)) } + def deployment_version + end + + # Required. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentVersion)).void } + def deployment_version=(value) + end + + # Required. + sig { void } + def clear_deployment_version + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def upsert_entries + end + + sig { params(value: ::Google::Protobuf::Map).void } + def upsert_entries=(value) + end + + sig { void } + def clear_upsert_entries + end + + # List of keys to remove from the metadata. + sig { returns(T::Array[String]) } + def remove_entries + end + + # List of keys to remove from the metadata. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def remove_entries=(value) + end + + # List of keys to remove from the metadata. + sig { void } + def clear_remove_entries + end + + # Optional. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Optional. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Optional. The identity of the client who initiated this request. + sig { void } + def clear_identity + 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::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataRequest, 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::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + metadata: T.nilable(Temporalio::Api::Deployment::V1::VersionMetadata) + ).void + end + def initialize( + metadata: nil + ) + end + + # Full metadata after performing the update. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::VersionMetadata)) } + def metadata + end + + # Full metadata after performing the update. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::VersionMetadata)).void } + def metadata=(value) + end + + # Full metadata after performing the update. + 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::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Update the ManagerIdentity of a Worker Deployment. +class Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment_name: T.nilable(String), + manager_identity: T.nilable(String), + self: T.nilable(T::Boolean), + conflict_token: T.nilable(String), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + deployment_name: "", + manager_identity: "", + self: false, + conflict_token: "", + identity: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def deployment_name + end + + sig { params(value: String).void } + def deployment_name=(value) + end + + sig { void } + def clear_deployment_name + end + + # Arbitrary value for `manager_identity`. +# Empty will unset the field. + sig { returns(String) } + def manager_identity + end + + # Arbitrary value for `manager_identity`. +# Empty will unset the field. + sig { params(value: String).void } + def manager_identity=(value) + end + + # Arbitrary value for `manager_identity`. +# Empty will unset the field. + sig { void } + def clear_manager_identity + end + + # True will set `manager_identity` to `identity`. + sig { returns(T::Boolean) } + def self + end + + # True will set `manager_identity` to `identity`. + sig { params(value: T::Boolean).void } + def self=(value) + end + + # True will set `manager_identity` to `identity`. + sig { void } + def clear_self + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { returns(String) } + def conflict_token + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { params(value: String).void } + def conflict_token=(value) + end + + # Optional. This can be the value of conflict_token from a Describe, or another Worker +# Deployment API. Passing a non-nil conflict token will cause this request to fail if the +# Deployment's configuration has been modified between the API call that generated the +# token and this one. + sig { void } + def clear_conflict_token + end + + # Required. The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # Required. The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # Required. The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + sig { returns(T.nilable(Symbol)) } + def new_manager_identity + 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::WorkflowService::V1::SetWorkerDeploymentManagerRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerRequest, 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::WorkflowService::V1::SetWorkerDeploymentManagerResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + conflict_token: T.nilable(String), + previous_manager_identity: T.nilable(String) + ).void + end + def initialize( + conflict_token: "", + previous_manager_identity: "" + ) + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { returns(String) } + def conflict_token + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { params(value: String).void } + def conflict_token=(value) + end + + # This value is returned so that it can be optionally passed to APIs +# that write to the Worker Deployment state to ensure that the state +# did not change between this API call and a future write. + sig { void } + def clear_conflict_token + end + + # What the `manager_identity` field was before this change. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# manager identity before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { returns(String) } + def previous_manager_identity + end + + # What the `manager_identity` field was before this change. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# manager identity before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { params(value: String).void } + def previous_manager_identity=(value) + end + + # What the `manager_identity` field was before this change. +# Deprecated in favor of idempotency of the API. Use `DescribeWorkerDeployment` to get the +# manager identity before calling this API. By passing the `conflict_token` got from the +# `DescribeWorkerDeployment` call to this API you can ensure there is no interfering changes +# between the two calls. + sig { void } + def clear_previous_manager_identity + 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::WorkflowService::V1::SetWorkerDeploymentManagerResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Returns the Current Deployment of a deployment series. +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + series_name: T.nilable(String) + ).void + end + def initialize( + namespace: "", + series_name: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def series_name + end + + sig { params(value: String).void } + def series_name=(value) + end + + sig { void } + def clear_series_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::WorkflowService::V1::GetCurrentDeploymentRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + current_deployment_info: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo) + ).void + end + def initialize( + current_deployment_info: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)) } + def current_deployment_info + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)).void } + def current_deployment_info=(value) + end + + sig { void } + def clear_current_deployment_info + 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::WorkflowService::V1::GetCurrentDeploymentResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + deployment: T.nilable(Temporalio::Api::Deployment::V1::Deployment) + ).void + end + def initialize( + namespace: "", + deployment: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::Deployment)) } + def deployment + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::Deployment)).void } + def deployment=(value) + end + + sig { void } + def clear_deployment + 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::WorkflowService::V1::GetDeploymentReachabilityRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# [cleanup-wv-pre-release] Pre-release deployment APIs, clean up later +class Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deployment_info: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo), + reachability: T.nilable(T.any(Symbol, String, Integer)), + last_update_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + deployment_info: nil, + reachability: :DEPLOYMENT_REACHABILITY_UNSPECIFIED, + last_update_time: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)) } + def deployment_info + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::DeploymentInfo)).void } + def deployment_info=(value) + end + + sig { void } + def clear_deployment_info + end + + sig { returns(T.any(Symbol, Integer)) } + def reachability + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def reachability=(value) + end + + sig { void } + def clear_reachability + end + + # Reachability level might come from server cache. This timestamp specifies when the value +# was actually calculated. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def last_update_time + end + + # Reachability level might come from server cache. This timestamp specifies when the value +# was actually calculated. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def last_update_time=(value) + end + + # Reachability level might come from server cache. This timestamp specifies when the value +# was actually calculated. + sig { void } + def clear_last_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::WorkflowService::V1::GetDeploymentReachabilityResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityResponse, 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::WorkflowService::V1::CreateWorkflowRuleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + spec: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec), + force_scan: T.nilable(T::Boolean), + request_id: T.nilable(String), + identity: T.nilable(String), + description: T.nilable(String) + ).void + end + def initialize( + namespace: "", + spec: nil, + force_scan: false, + request_id: "", + identity: "", + description: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # The rule specification . + sig { returns(T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec)) } + def spec + end + + # The rule specification . + sig { params(value: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec)).void } + def spec=(value) + end + + # The rule specification . + sig { void } + def clear_spec + end + + # If true, the rule will be applied to the currently running workflows via batch job. +# If not set , the rule will only be applied when triggering condition is satisfied. +# visibility_query in the rule will be used to select the workflows to apply the rule to. + sig { returns(T::Boolean) } + def force_scan + end + + # If true, the rule will be applied to the currently running workflows via batch job. +# If not set , the rule will only be applied when triggering condition is satisfied. +# visibility_query in the rule will be used to select the workflows to apply the rule to. + sig { params(value: T::Boolean).void } + def force_scan=(value) + end + + # If true, the rule will be applied to the currently running workflows via batch job. +# If not set , the rule will only be applied when triggering condition is satisfied. +# visibility_query in the rule will be used to select the workflows to apply the rule to. + sig { void } + def clear_force_scan + end + + # Used to de-dupe requests. Typically should be UUID. + sig { returns(String) } + def request_id + end + + # Used to de-dupe requests. Typically should be UUID. + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe requests. Typically should be UUID. + sig { void } + def clear_request_id + end + + # Identity of the actor who created the rule. Will be stored with the rule. + sig { returns(String) } + def identity + end + + # Identity of the actor who created the rule. Will be stored with the rule. + sig { params(value: String).void } + def identity=(value) + end + + # Identity of the actor who created the rule. Will be stored with the rule. + sig { void } + def clear_identity + end + + # Rule description.Will be stored with the rule. + sig { returns(String) } + def description + end + + # Rule description.Will be stored with the rule. + sig { params(value: String).void } + def description=(value) + end + + # Rule description.Will be stored with the rule. + sig { void } + def clear_description + 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::WorkflowService::V1::CreateWorkflowRuleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleRequest, 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::WorkflowService::V1::CreateWorkflowRuleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rule: T.nilable(Temporalio::Api::Rules::V1::WorkflowRule), + job_id: T.nilable(String) + ).void + end + def initialize( + rule: nil, + job_id: "" + ) + end + + # Created rule. + sig { returns(T.nilable(Temporalio::Api::Rules::V1::WorkflowRule)) } + def rule + end + + # Created rule. + sig { params(value: T.nilable(Temporalio::Api::Rules::V1::WorkflowRule)).void } + def rule=(value) + end + + # Created rule. + sig { void } + def clear_rule + end + + # Batch Job ID if force-scan flag was provided. Otherwise empty. + sig { returns(String) } + def job_id + end + + # Batch Job ID if force-scan flag was provided. Otherwise empty. + sig { params(value: String).void } + def job_id=(value) + end + + # Batch Job ID if force-scan flag was provided. Otherwise empty. + sig { void } + def clear_job_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::WorkflowService::V1::CreateWorkflowRuleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleResponse, 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::WorkflowService::V1::DescribeWorkflowRuleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + rule_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + rule_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # User-specified ID of the rule to read. Unique within the namespace. + sig { returns(String) } + def rule_id + end + + # User-specified ID of the rule to read. Unique within the namespace. + sig { params(value: String).void } + def rule_id=(value) + end + + # User-specified ID of the rule to read. Unique within the namespace. + sig { void } + def clear_rule_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::WorkflowService::V1::DescribeWorkflowRuleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleRequest, 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::WorkflowService::V1::DescribeWorkflowRuleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rule: T.nilable(Temporalio::Api::Rules::V1::WorkflowRule) + ).void + end + def initialize( + rule: nil + ) + end + + # The rule that was read. + sig { returns(T.nilable(Temporalio::Api::Rules::V1::WorkflowRule)) } + def rule + end + + # The rule that was read. + sig { params(value: T.nilable(Temporalio::Api::Rules::V1::WorkflowRule)).void } + def rule=(value) + end + + # The rule that was read. + sig { void } + def clear_rule + 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::WorkflowService::V1::DescribeWorkflowRuleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleResponse, 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::WorkflowService::V1::DeleteWorkflowRuleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + rule_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + rule_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # ID of the rule to delete. Unique within the namespace. + sig { returns(String) } + def rule_id + end + + # ID of the rule to delete. Unique within the namespace. + sig { params(value: String).void } + def rule_id=(value) + end + + # ID of the rule to delete. Unique within the namespace. + sig { void } + def clear_rule_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::WorkflowService::V1::DeleteWorkflowRuleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleRequest, 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::WorkflowService::V1::DeleteWorkflowRuleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::DeleteWorkflowRuleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleResponse, 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::WorkflowService::V1::ListWorkflowRulesRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + next_page_token: T.nilable(String) + ).void + end + def initialize( + namespace: "", + next_page_token: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListWorkflowRulesRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkflowRulesRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkflowRulesRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkflowRulesRequest, 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::WorkflowService::V1::ListWorkflowRulesResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rules: T.nilable(T::Array[T.nilable(Temporalio::Api::Rules::V1::WorkflowRule)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + rules: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Rules::V1::WorkflowRule)]) } + def rules + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def rules=(value) + end + + sig { void } + def clear_rules + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListWorkflowRulesResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkflowRulesResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkflowRulesResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkflowRulesResponse, 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::WorkflowService::V1::TriggerWorkflowRuleRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + id: T.nilable(String), + spec: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec), + identity: T.nilable(String) + ).void + end + def initialize( + namespace: "", + execution: nil, + id: "", + spec: nil, + identity: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Execution info of the workflow which scheduled this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def execution + end + + # Execution info of the workflow which scheduled this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def execution=(value) + end + + # Execution info of the workflow which scheduled this activity + sig { void } + def clear_execution + end + + sig { returns(String) } + def id + end + + sig { params(value: String).void } + def id=(value) + end + + sig { void } + def clear_id + end + + # Note: Rule ID and expiration date are not used in the trigger request. + sig { returns(T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec)) } + def spec + end + + # Note: Rule ID and expiration date are not used in the trigger request. + sig { params(value: T.nilable(Temporalio::Api::Rules::V1::WorkflowRuleSpec)).void } + def spec=(value) + end + + # Note: Rule ID and expiration date are not used in the trigger request. + sig { void } + def clear_spec + end + + # The identity of the client who initiated this request + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request + sig { void } + def clear_identity + end + + sig { returns(T.nilable(Symbol)) } + def rule + 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::WorkflowService::V1::TriggerWorkflowRuleRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleRequest, 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::WorkflowService::V1::TriggerWorkflowRuleResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + applied: T.nilable(T::Boolean) + ).void + end + def initialize( + applied: false + ) + end + + # True is the rule was applied, based on the rule conditions (predicate/visibility_query). + sig { returns(T::Boolean) } + def applied + end + + # True is the rule was applied, based on the rule conditions (predicate/visibility_query). + sig { params(value: T::Boolean).void } + def applied=(value) + end + + # True is the rule was applied, based on the rule conditions (predicate/visibility_query). + sig { void } + def clear_applied + 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::WorkflowService::V1::TriggerWorkflowRuleResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleResponse, 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::WorkflowService::V1::RecordWorkerHeartbeatRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + identity: T.nilable(String), + worker_heartbeat: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat)]), + resource_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + identity: "", + worker_heartbeat: [], + resource_id: "" + ) + end + + # Namespace this worker belongs to. + sig { returns(String) } + def namespace + end + + # Namespace this worker belongs to. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace this worker belongs to. + sig { void } + def clear_namespace + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerHeartbeat)]) } + def worker_heartbeat + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def worker_heartbeat=(value) + end + + sig { void } + def clear_worker_heartbeat + end + + # Resource ID for routing. Contains the worker grouping key. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the worker grouping key. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the worker grouping key. + sig { void } + def clear_resource_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::WorkflowService::V1::RecordWorkerHeartbeatRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatRequest, 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::WorkflowService::V1::RecordWorkerHeartbeatResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RecordWorkerHeartbeatResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatResponse, 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::WorkflowService::V1::ListWorkersRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(Integer) } + def page_size + end + + sig { params(value: Integer).void } + def page_size=(value) + end + + sig { void } + def clear_page_size + end + + sig { returns(String) } + def next_page_token + end + + sig { params(value: String).void } + def next_page_token=(value) + end + + sig { void } + def clear_next_page_token + end + + # `query` in ListWorkers is used to filter workers based on worker attributes. +# Supported attributes: +#* WorkerInstanceKey +#* WorkerIdentity +#* HostName +#* TaskQueue +#* DeploymentName +#* BuildId +#* SdkName +#* SdkVersion +#* StartTime +#* Status + sig { returns(String) } + def query + end + + # `query` in ListWorkers is used to filter workers based on worker attributes. +# Supported attributes: +#* WorkerInstanceKey +#* WorkerIdentity +#* HostName +#* TaskQueue +#* DeploymentName +#* BuildId +#* SdkName +#* SdkVersion +#* StartTime +#* Status + sig { params(value: String).void } + def query=(value) + end + + # `query` in ListWorkers is used to filter workers based on worker attributes. +# Supported attributes: +#* WorkerInstanceKey +#* WorkerIdentity +#* HostName +#* TaskQueue +#* DeploymentName +#* BuildId +#* SdkName +#* SdkVersion +#* StartTime +#* Status + sig { void } + def clear_query + 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::WorkflowService::V1::ListWorkersRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkersRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkersRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkersRequest, 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::WorkflowService::V1::ListWorkersResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workers_info: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerInfo)]), + workers: T.nilable(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerListInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + workers_info: [], + workers: [], + next_page_token: "" + ) + end + + # Deprecated: Use workers instead. This field returns full WorkerInfo which +# includes expensive runtime metrics. We will stop populating this field in the future. + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerInfo)]) } + def workers_info + end + + # Deprecated: Use workers instead. This field returns full WorkerInfo which +# includes expensive runtime metrics. We will stop populating this field in the future. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def workers_info=(value) + end + + # Deprecated: Use workers instead. This field returns full WorkerInfo which +# includes expensive runtime metrics. We will stop populating this field in the future. + sig { void } + def clear_workers_info + end + + # Limited worker information. + sig { returns(T::Array[T.nilable(Temporalio::Api::Worker::V1::WorkerListInfo)]) } + def workers + end + + # Limited worker information. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def workers=(value) + end + + # Limited worker information. + sig { void } + def clear_workers + end + + # Next page token + sig { returns(String) } + def next_page_token + end + + # Next page token + sig { params(value: String).void } + def next_page_token=(value) + end + + # Next page token + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListWorkersResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkersResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkersResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkersResponse, 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::WorkflowService::V1::UpdateTaskQueueConfigRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + identity: T.nilable(String), + task_queue: T.nilable(String), + task_queue_type: T.nilable(T.any(Symbol, String, Integer)), + update_queue_rate_limit: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate), + update_fairness_key_rate_limit_default: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate), + set_fairness_weight_overrides: T.nilable(T::Hash[String, Float]), + unset_fairness_weight_overrides: T.nilable(T::Array[String]) + ).void + end + def initialize( + namespace: "", + identity: "", + task_queue: "", + task_queue_type: :TASK_QUEUE_TYPE_UNSPECIFIED, + update_queue_rate_limit: nil, + update_fairness_key_rate_limit_default: nil, + set_fairness_weight_overrides: ::Google::Protobuf::Map.new(:string, :float), + unset_fairness_weight_overrides: [] + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def identity + end + + sig { params(value: String).void } + def identity=(value) + end + + sig { void } + def clear_identity + end + + # Selects the task queue to update. + sig { returns(String) } + def task_queue + end + + # Selects the task queue to update. + sig { params(value: String).void } + def task_queue=(value) + end + + # Selects the task queue to update. + sig { void } + def clear_task_queue + end + + sig { returns(T.any(Symbol, Integer)) } + def task_queue_type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def task_queue_type=(value) + end + + sig { void } + def clear_task_queue_type + end + + # Update to queue-wide rate limit. +# If not set, this configuration is unchanged. +# NOTE: A limit set by the worker is overriden; and restored again when reset. +# If the `rate_limit` field in the `RateLimitUpdate` is missing, remove the existing rate limit. + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate)) } + def update_queue_rate_limit + end + + # Update to queue-wide rate limit. +# If not set, this configuration is unchanged. +# NOTE: A limit set by the worker is overriden; and restored again when reset. +# If the `rate_limit` field in the `RateLimitUpdate` is missing, remove the existing rate limit. + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate)).void } + def update_queue_rate_limit=(value) + end + + # Update to queue-wide rate limit. +# If not set, this configuration is unchanged. +# NOTE: A limit set by the worker is overriden; and restored again when reset. +# If the `rate_limit` field in the `RateLimitUpdate` is missing, remove the existing rate limit. + sig { void } + def clear_update_queue_rate_limit + end + + # Update to the default fairness key rate limit. +# If not set, this configuration is unchanged. +# If the `rate_limit` field in the `RateLimitUpdate` is missing, remove the existing rate limit. + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate)) } + def update_fairness_key_rate_limit_default + end + + # Update to the default fairness key rate limit. +# If not set, this configuration is unchanged. +# If the `rate_limit` field in the `RateLimitUpdate` is missing, remove the existing rate limit. + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate)).void } + def update_fairness_key_rate_limit_default=(value) + end + + # Update to the default fairness key rate limit. +# If not set, this configuration is unchanged. +# If the `rate_limit` field in the `RateLimitUpdate` is missing, remove the existing rate limit. + sig { void } + def clear_update_fairness_key_rate_limit_default + end + + # If set, overrides the fairness weight for each specified fairness key. +# Fairness keys not listed in this map will keep their existing overrides (if any). + sig { returns(T::Hash[String, Float]) } + def set_fairness_weight_overrides + end + + # If set, overrides the fairness weight for each specified fairness key. +# Fairness keys not listed in this map will keep their existing overrides (if any). + sig { params(value: ::Google::Protobuf::Map).void } + def set_fairness_weight_overrides=(value) + end + + # If set, overrides the fairness weight for each specified fairness key. +# Fairness keys not listed in this map will keep their existing overrides (if any). + sig { void } + def clear_set_fairness_weight_overrides + end + + # If set, removes any existing fairness weight overrides for each specified fairness key. +# Fairness weights for corresponding keys fall back to the values set during task creation (if any), +# or to the default weight of 1.0. + sig { returns(T::Array[String]) } + def unset_fairness_weight_overrides + end + + # If set, removes any existing fairness weight overrides for each specified fairness key. +# Fairness weights for corresponding keys fall back to the values set during task creation (if any), +# or to the default weight of 1.0. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def unset_fairness_weight_overrides=(value) + end + + # If set, removes any existing fairness weight overrides for each specified fairness key. +# Fairness weights for corresponding keys fall back to the values set during task creation (if any), +# or to the default weight of 1.0. + sig { void } + def clear_unset_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::WorkflowService::V1::UpdateTaskQueueConfigRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest, 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::WorkflowService::V1::UpdateTaskQueueConfigResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + config: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueConfig) + ).void + end + def initialize( + config: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueConfig)) } + def config + end + + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueConfig)).void } + def config=(value) + end + + sig { void } + def clear_config + 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::WorkflowService::V1::UpdateTaskQueueConfigResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigResponse, 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::WorkflowService::V1::FetchWorkerConfigRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + identity: T.nilable(String), + reason: T.nilable(String), + selector: T.nilable(Temporalio::Api::Common::V1::WorkerSelector), + resource_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + identity: "", + reason: "", + selector: nil, + resource_id: "" + ) + end + + # Namespace this worker belongs to. + sig { returns(String) } + def namespace + end + + # Namespace this worker belongs to. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace this worker belongs to. + sig { void } + def clear_namespace + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Reason for sending worker command, can be used for audit purpose. + sig { returns(String) } + def reason + end + + # Reason for sending worker command, can be used for audit purpose. + sig { params(value: String).void } + def reason=(value) + end + + # Reason for sending worker command, can be used for audit purpose. + sig { void } + def clear_reason + end + + # Defines which workers should receive this command. +# only single worker is supported at this time. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerSelector)) } + def selector + end + + # Defines which workers should receive this command. +# only single worker is supported at this time. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerSelector)).void } + def selector=(value) + end + + # Defines which workers should receive this command. +# only single worker is supported at this time. + sig { void } + def clear_selector + end + + # Resource ID for routing. Contains the worker grouping key. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the worker grouping key. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the worker grouping key. + sig { void } + def clear_resource_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::WorkflowService::V1::FetchWorkerConfigRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::FetchWorkerConfigRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::FetchWorkerConfigRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::FetchWorkerConfigRequest, 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::WorkflowService::V1::FetchWorkerConfigResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_config: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig) + ).void + end + def initialize( + worker_config: nil + ) + end + + # The worker configuration. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig)) } + def worker_config + end + + # The worker configuration. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig)).void } + def worker_config=(value) + end + + # The worker configuration. + sig { void } + def clear_worker_config + 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::WorkflowService::V1::FetchWorkerConfigResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::FetchWorkerConfigResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::FetchWorkerConfigResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::FetchWorkerConfigResponse, 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::WorkflowService::V1::UpdateWorkerConfigRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + identity: T.nilable(String), + reason: T.nilable(String), + worker_config: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig), + update_mask: T.nilable(Google::Protobuf::FieldMask), + selector: T.nilable(Temporalio::Api::Common::V1::WorkerSelector), + resource_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + identity: "", + reason: "", + worker_config: nil, + update_mask: nil, + selector: nil, + resource_id: "" + ) + end + + # Namespace this worker belongs to. + sig { returns(String) } + def namespace + end + + # Namespace this worker belongs to. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace this worker belongs to. + sig { void } + def clear_namespace + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Reason for sending worker command, can be used for audit purpose. + sig { returns(String) } + def reason + end + + # Reason for sending worker command, can be used for audit purpose. + sig { params(value: String).void } + def reason=(value) + end + + # Reason for sending worker command, can be used for audit purpose. + sig { void } + def clear_reason + end + + # Partial updates are accepted and controlled by update_mask. +# The worker configuration to set. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig)) } + def worker_config + end + + # Partial updates are accepted and controlled by update_mask. +# The worker configuration to set. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig)).void } + def worker_config=(value) + end + + # Partial updates are accepted and controlled by update_mask. +# The worker configuration to set. + sig { void } + def clear_worker_config + end + + # Controls which fields from `worker_config` will be applied + sig { returns(T.nilable(Google::Protobuf::FieldMask)) } + def update_mask + end + + # Controls which fields from `worker_config` will be applied + sig { params(value: T.nilable(Google::Protobuf::FieldMask)).void } + def update_mask=(value) + end + + # Controls which fields from `worker_config` will be applied + sig { void } + def clear_update_mask + end + + # Defines which workers should receive this command. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkerSelector)) } + def selector + end + + # Defines which workers should receive this command. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkerSelector)).void } + def selector=(value) + end + + # Defines which workers should receive this command. + sig { void } + def clear_selector + end + + # Resource ID for routing. Contains the worker grouping key. + sig { returns(String) } + def resource_id + end + + # Resource ID for routing. Contains the worker grouping key. + sig { params(value: String).void } + def resource_id=(value) + end + + # Resource ID for routing. Contains the worker grouping key. + sig { void } + def clear_resource_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::WorkflowService::V1::UpdateWorkerConfigRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerConfigRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerConfigRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerConfigRequest, 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::WorkflowService::V1::UpdateWorkerConfigResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_config: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig) + ).void + end + def initialize( + worker_config: nil + ) + end + + # The worker configuration. Will be returned if the command was sent to a single worker. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig)) } + def worker_config + end + + # The worker configuration. Will be returned if the command was sent to a single worker. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::WorkerConfig)).void } + def worker_config=(value) + end + + # The worker configuration. Will be returned if the command was sent to a single worker. + sig { void } + def clear_worker_config + end + + sig { returns(T.nilable(Symbol)) } + def response + 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::WorkflowService::V1::UpdateWorkerConfigResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerConfigResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerConfigResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerConfigResponse, 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::WorkflowService::V1::DescribeWorkerRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + worker_instance_key: T.nilable(String) + ).void + end + def initialize( + namespace: "", + worker_instance_key: "" + ) + end + + # Namespace this worker belongs to. + sig { returns(String) } + def namespace + end + + # Namespace this worker belongs to. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace this worker belongs to. + sig { void } + def clear_namespace + end + + # Worker instance key to describe. + sig { returns(String) } + def worker_instance_key + end + + # Worker instance key to describe. + sig { params(value: String).void } + def worker_instance_key=(value) + end + + # Worker instance key to describe. + sig { void } + def clear_worker_instance_key + 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::WorkflowService::V1::DescribeWorkerRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerRequest, 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::WorkflowService::V1::DescribeWorkerResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + worker_info: T.nilable(Temporalio::Api::Worker::V1::WorkerInfo) + ).void + end + def initialize( + worker_info: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Worker::V1::WorkerInfo)) } + def worker_info + end + + sig { params(value: T.nilable(Temporalio::Api::Worker::V1::WorkerInfo)).void } + def worker_info=(value) + end + + sig { void } + def clear_worker_info + 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::WorkflowService::V1::DescribeWorkerResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Request to pause a workflow execution. +class Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String), + identity: T.nilable(String), + reason: T.nilable(String), + request_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "", + identity: "", + reason: "", + request_id: "" + ) + end + + # Namespace of the workflow to pause. + sig { returns(String) } + def namespace + end + + # Namespace of the workflow to pause. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow to pause. + sig { void } + def clear_namespace + end + + # ID of the workflow execution to be paused. Required. + sig { returns(String) } + def workflow_id + end + + # ID of the workflow execution to be paused. Required. + sig { params(value: String).void } + def workflow_id=(value) + end + + # ID of the workflow execution to be paused. Required. + sig { void } + def clear_workflow_id + end + + # Run ID of the workflow execution to be paused. Optional. If not provided, the current run of the workflow will be paused. + sig { returns(String) } + def run_id + end + + # Run ID of the workflow execution to be paused. Optional. If not provided, the current run of the workflow will be paused. + sig { params(value: String).void } + def run_id=(value) + end + + # Run ID of the workflow execution to be paused. Optional. If not provided, the current run of the workflow will be paused. + sig { void } + def clear_run_id + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Reason to pause the workflow execution. + sig { returns(String) } + def reason + end + + # Reason to pause the workflow execution. + sig { params(value: String).void } + def reason=(value) + end + + # Reason to pause the workflow execution. + sig { void } + def clear_reason + end + + # A unique identifier for this pause request for idempotence. Typically UUIDv4. + sig { returns(String) } + def request_id + end + + # A unique identifier for this pause request for idempotence. Typically UUIDv4. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this pause request for idempotence. Typically UUIDv4. + sig { void } + def clear_request_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::WorkflowService::V1::PauseWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Response to a successful PauseWorkflowExecution request. +class Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::PauseWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionResponse, 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::WorkflowService::V1::UnpauseWorkflowExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String), + identity: T.nilable(String), + reason: T.nilable(String), + request_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "", + identity: "", + reason: "", + request_id: "" + ) + end + + # Namespace of the workflow to unpause. + sig { returns(String) } + def namespace + end + + # Namespace of the workflow to unpause. + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace of the workflow to unpause. + sig { void } + def clear_namespace + end + + # ID of the workflow execution to be paused. Required. + sig { returns(String) } + def workflow_id + end + + # ID of the workflow execution to be paused. Required. + sig { params(value: String).void } + def workflow_id=(value) + end + + # ID of the workflow execution to be paused. Required. + sig { void } + def clear_workflow_id + end + + # Run ID of the workflow execution to be paused. Optional. If not provided, the current run of the workflow will be paused. + sig { returns(String) } + def run_id + end + + # Run ID of the workflow execution to be paused. Optional. If not provided, the current run of the workflow will be paused. + sig { params(value: String).void } + def run_id=(value) + end + + # Run ID of the workflow execution to be paused. Optional. If not provided, the current run of the workflow will be paused. + sig { void } + def clear_run_id + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Reason to unpause the workflow execution. + sig { returns(String) } + def reason + end + + # Reason to unpause the workflow execution. + sig { params(value: String).void } + def reason=(value) + end + + # Reason to unpause the workflow execution. + sig { void } + def clear_reason + end + + # A unique identifier for this unpause request for idempotence. Typically UUIDv4. + sig { returns(String) } + def request_id + end + + # A unique identifier for this unpause request for idempotence. Typically UUIDv4. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this unpause request for idempotence. Typically UUIDv4. + sig { void } + def clear_request_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::WorkflowService::V1::UnpauseWorkflowExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionRequest, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Response to a successful UnpauseWorkflowExecution request. +class Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::UnpauseWorkflowExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionResponse, 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::WorkflowService::V1::StartActivityExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + identity: T.nilable(String), + request_id: T.nilable(String), + activity_id: T.nilable(String), + activity_type: T.nilable(Temporalio::Api::Common::V1::ActivityType), + task_queue: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + heartbeat_timeout: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + id_reuse_policy: T.nilable(T.any(Symbol, String, Integer)), + id_conflict_policy: T.nilable(T.any(Symbol, String, Integer)), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + header: T.nilable(Temporalio::Api::Common::V1::Header), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + completion_callbacks: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Callback)]), + links: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]), + on_conflict_options: T.nilable(Temporalio::Api::Common::V1::OnConflictOptions), + start_delay: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + namespace: "", + identity: "", + request_id: "", + activity_id: "", + activity_type: nil, + task_queue: nil, + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + heartbeat_timeout: nil, + retry_policy: nil, + input: nil, + id_reuse_policy: :ACTIVITY_ID_REUSE_POLICY_UNSPECIFIED, + id_conflict_policy: :ACTIVITY_ID_CONFLICT_POLICY_UNSPECIFIED, + search_attributes: nil, + header: nil, + user_metadata: nil, + priority: nil, + completion_callbacks: [], + links: [], + on_conflict_options: nil, + start_delay: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # The identity of the client who initiated this request + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request + sig { void } + def clear_identity + end + + # A unique identifier for this start request. Typically UUIDv4. + sig { returns(String) } + def request_id + end + + # A unique identifier for this start request. Typically UUIDv4. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this start request. Typically UUIDv4. + sig { void } + def clear_request_id + end + + # Identifier for this activity. Required. This identifier should be meaningful in the user's +# own system. It must be unique among activities in the same namespace, subject to the rules +# imposed by id_reuse_policy and id_conflict_policy. + sig { returns(String) } + def activity_id + end + + # Identifier for this activity. Required. This identifier should be meaningful in the user's +# own system. It must be unique among activities in the same namespace, subject to the rules +# imposed by id_reuse_policy and id_conflict_policy. + sig { params(value: String).void } + def activity_id=(value) + end + + # Identifier for this activity. Required. This identifier should be meaningful in the user's +# own system. It must be unique among activities in the same namespace, subject to the rules +# imposed by id_reuse_policy and id_conflict_policy. + sig { void } + def clear_activity_id + end + + # The type of the activity, a string that corresponds to a registered activity on a worker. + sig { returns(T.nilable(Temporalio::Api::Common::V1::ActivityType)) } + def activity_type + end + + # The type of the activity, a string that corresponds to a registered activity on a worker. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::ActivityType)).void } + def activity_type=(value) + end + + # The type of the activity, a string that corresponds to a registered activity on a worker. + sig { void } + def clear_activity_type + end + + # Task queue to schedule this activity on. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)) } + def task_queue + end + + # Task queue to schedule this activity on. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueue)).void } + def task_queue=(value) + end + + # Task queue to schedule this activity on. + sig { void } + def clear_task_queue + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- 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_close_timeout + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- 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_close_timeout=(value) + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or `start_to_close_timeout` must be specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` if not specified. +# +# (-- 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 + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` if not specified. +# +# (-- 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 + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable, as all a retry would achieve is to put it back into the same +# queue. Defaults to `schedule_to_close_timeout` if not specified. +# +# (-- 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 + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- 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 start_to_close_timeout=(value) + end + + # Maximum time an activity is allowed to execute after being picked up by a worker. This +# timeout is always retryable. Either this or `schedule_to_close_timeout` must be +# specified. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def heartbeat_timeout + end + + # Maximum permitted time between successful worker heartbeats. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def heartbeat_timeout=(value) + end + + # Maximum permitted time between successful worker heartbeats. + sig { void } + def clear_heartbeat_timeout + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # The retry policy for the activity. Will never exceed `schedule_to_close_timeout`. + sig { void } + def clear_retry_policy + end + + # Serialized arguments to the activity. These are passed as arguments to the activity function. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized arguments to the activity. These are passed as arguments to the activity function. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized arguments to the activity. These are passed as arguments to the activity function. + sig { void } + def clear_input + end + + # Defines whether to allow re-using the activity id from a previously *closed* activity. +# The default policy is ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { returns(T.any(Symbol, Integer)) } + def id_reuse_policy + end + + # Defines whether to allow re-using the activity id from a previously *closed* activity. +# The default policy is ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def id_reuse_policy=(value) + end + + # Defines whether to allow re-using the activity id from a previously *closed* activity. +# The default policy is ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { void } + def clear_id_reuse_policy + end + + # Defines how to resolve an activity id conflict with a *running* activity. +# The default policy is ACTIVITY_ID_CONFLICT_POLICY_FAIL. + sig { returns(T.any(Symbol, Integer)) } + def id_conflict_policy + end + + # Defines how to resolve an activity id conflict with a *running* activity. +# The default policy is ACTIVITY_ID_CONFLICT_POLICY_FAIL. + sig { params(value: T.any(Symbol, String, Integer)).void } + def id_conflict_policy=(value) + end + + # Defines how to resolve an activity id conflict with a *running* activity. +# The default policy is ACTIVITY_ID_CONFLICT_POLICY_FAIL. + sig { void } + def clear_id_conflict_policy + end + + # Search attributes for indexing. + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # Search attributes for indexing. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # Search attributes for indexing. + sig { void } + def clear_search_attributes + end + + # Header for context propagation and tracing purposes. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Header)) } + def header + end + + # Header for context propagation and tracing purposes. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Header)).void } + def header=(value) + end + + # Header for context propagation and tracing purposes. + sig { void } + def clear_header + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity. + sig { void } + def clear_user_metadata + end + + # Priority metadata. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority metadata. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority metadata. + sig { void } + def clear_priority + end + + # Callbacks to be called by the server when this activity reaches a terminal state. +# Callback addresses must be whitelisted in the server's dynamic configuration. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Callback)]) } + def completion_callbacks + end + + # Callbacks to be called by the server when this activity reaches a terminal state. +# Callback addresses must be whitelisted in the server's dynamic configuration. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def completion_callbacks=(value) + end + + # Callbacks to be called by the server when this activity reaches a terminal state. +# Callback addresses must be whitelisted in the server's dynamic configuration. + sig { void } + def clear_completion_callbacks + end + + # Links to be associated with the activity. Callbacks may also have associated links; +# links already included with a callback should not be duplicated here. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Link)]) } + def links + end + + # Links to be associated with the activity. Callbacks may also have associated links; +# links already included with a callback should not be duplicated here. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def links=(value) + end + + # Links to be associated with the activity. Callbacks may also have associated links; +# links already included with a callback should not be duplicated here. + sig { void } + def clear_links + end + + # Options for handling conflicts when using ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING. + sig { returns(T.nilable(Temporalio::Api::Common::V1::OnConflictOptions)) } + def on_conflict_options + end + + # Options for handling conflicts when using ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::OnConflictOptions)).void } + def on_conflict_options=(value) + end + + # Options for handling conflicts when using ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING. + sig { void } + def clear_on_conflict_options + end + + # Time to wait before dispatching the first activity task. This delay is not applied to retry attempts. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_delay + end + + # Time to wait before dispatching the first activity task. This delay is not applied to retry attempts. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def start_delay=(value) + end + + # Time to wait before dispatching the first activity task. This delay is not applied to retry attempts. + sig { void } + def clear_start_delay + 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::WorkflowService::V1::StartActivityExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartActivityExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StartActivityExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartActivityExecutionRequest, 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::WorkflowService::V1::StartActivityExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + started: T.nilable(T::Boolean), + link: T.nilable(Temporalio::Api::Common::V1::Link) + ).void + end + def initialize( + run_id: "", + started: false, + link: nil + ) + end + + # The run ID of the activity that was started - or used (via ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING). + sig { returns(String) } + def run_id + end + + # The run ID of the activity that was started - or used (via ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING). + sig { params(value: String).void } + def run_id=(value) + end + + # The run ID of the activity that was started - or used (via ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING). + sig { void } + def clear_run_id + end + + # If true, a new activity was started. + sig { returns(T::Boolean) } + def started + end + + # If true, a new activity was started. + sig { params(value: T::Boolean).void } + def started=(value) + end + + # If true, a new activity was started. + sig { void } + def clear_started + end + + # Link to the started activity. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Link)) } + def link + end + + # Link to the started activity. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Link)).void } + def link=(value) + end + + # Link to the started activity. + sig { void } + def clear_link + 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::WorkflowService::V1::StartActivityExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartActivityExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StartActivityExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartActivityExecutionResponse, 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::WorkflowService::V1::DescribeActivityExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + activity_id: T.nilable(String), + run_id: T.nilable(String), + include_input: T.nilable(T::Boolean), + include_outcome: T.nilable(T::Boolean), + long_poll_token: T.nilable(String) + ).void + end + def initialize( + namespace: "", + activity_id: "", + run_id: "", + include_input: false, + include_outcome: false, + long_poll_token: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + # Activity run ID. If empty the request targets the latest run. + sig { returns(String) } + def run_id + end + + # Activity run ID. If empty the request targets the latest run. + sig { params(value: String).void } + def run_id=(value) + end + + # Activity run ID. If empty the request targets the latest run. + sig { void } + def clear_run_id + end + + # Include the input field in the response. + sig { returns(T::Boolean) } + def include_input + end + + # Include the input field in the response. + sig { params(value: T::Boolean).void } + def include_input=(value) + end + + # Include the input field in the response. + sig { void } + def clear_include_input + end + + # Include the outcome (result/failure) in the response if the activity has completed. + sig { returns(T::Boolean) } + def include_outcome + end + + # Include the outcome (result/failure) in the response if the activity has completed. + sig { params(value: T::Boolean).void } + def include_outcome=(value) + end + + # Include the outcome (result/failure) in the response if the activity has completed. + sig { void } + def clear_include_outcome + end + + # Token from a previous DescribeActivityExecutionResponse. If present, long-poll until activity +# state changes from the state encoded in this token. If absent, return current state immediately. +# If present, run_id must also be present. +# Note that activity state may change multiple times between requests, therefore it is not +# guaranteed that a client making a sequence of long-poll requests will see a complete +# sequence of state changes. + sig { returns(String) } + def long_poll_token + end + + # Token from a previous DescribeActivityExecutionResponse. If present, long-poll until activity +# state changes from the state encoded in this token. If absent, return current state immediately. +# If present, run_id must also be present. +# Note that activity state may change multiple times between requests, therefore it is not +# guaranteed that a client making a sequence of long-poll requests will see a complete +# sequence of state changes. + sig { params(value: String).void } + def long_poll_token=(value) + end + + # Token from a previous DescribeActivityExecutionResponse. If present, long-poll until activity +# state changes from the state encoded in this token. If absent, return current state immediately. +# If present, run_id must also be present. +# Note that activity state may change multiple times between requests, therefore it is not +# guaranteed that a client making a sequence of long-poll requests will see a complete +# sequence of state changes. + sig { void } + def clear_long_poll_token + 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::WorkflowService::V1::DescribeActivityExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionRequest, 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::WorkflowService::V1::DescribeActivityExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + info: T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionInfo), + input: T.nilable(Temporalio::Api::Common::V1::Payloads), + outcome: T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionOutcome), + long_poll_token: T.nilable(String), + callbacks: T.nilable(T::Array[T.nilable(Temporalio::Api::Activity::V1::CallbackInfo)]) + ).void + end + def initialize( + run_id: "", + info: nil, + input: nil, + outcome: nil, + long_poll_token: "", + callbacks: [] + ) + end + + # The run ID of the activity, useful when run_id was not specified in the request. + sig { returns(String) } + def run_id + end + + # The run ID of the activity, useful when run_id was not specified in the request. + sig { params(value: String).void } + def run_id=(value) + end + + # The run ID of the activity, useful when run_id was not specified in the request. + sig { void } + def clear_run_id + end + + # Information about the activity execution. + sig { returns(T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionInfo)) } + def info + end + + # Information about the activity execution. + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionInfo)).void } + def info=(value) + end + + # Information about the activity execution. + sig { void } + def clear_info + end + + # Serialized activity input, passed as arguments to the activity function. +# Only set if include_input was true in the request. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def input + end + + # Serialized activity input, passed as arguments to the activity function. +# Only set if include_input was true in the request. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def input=(value) + end + + # Serialized activity input, passed as arguments to the activity function. +# Only set if include_input was true in the request. + sig { void } + def clear_input + end + + # Only set if the activity is completed and include_outcome was true in the request. + sig { returns(T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionOutcome)) } + def outcome + end + + # Only set if the activity is completed and include_outcome was true in the request. + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionOutcome)).void } + def outcome=(value) + end + + # Only set if the activity is completed and include_outcome was true in the request. + sig { void } + def clear_outcome + end + + # Token for follow-on long-poll requests. Absent only if the activity is complete. + sig { returns(String) } + def long_poll_token + end + + # Token for follow-on long-poll requests. Absent only if the activity is complete. + sig { params(value: String).void } + def long_poll_token=(value) + end + + # Token for follow-on long-poll requests. Absent only if the activity is complete. + sig { void } + def clear_long_poll_token + end + + # Callbacks attached to this activity execution and their current state. + sig { returns(T::Array[T.nilable(Temporalio::Api::Activity::V1::CallbackInfo)]) } + def callbacks + end + + # Callbacks attached to this activity execution and their current state. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def callbacks=(value) + end + + # Callbacks attached to this activity execution and their current state. + sig { void } + def clear_callbacks + 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::WorkflowService::V1::DescribeActivityExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionResponse, 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::WorkflowService::V1::PollActivityExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + activity_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + activity_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + # Activity run ID. If empty the request targets the latest run. + sig { returns(String) } + def run_id + end + + # Activity run ID. If empty the request targets the latest run. + sig { params(value: String).void } + def run_id=(value) + end + + # Activity run ID. If empty the request targets the latest run. + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::WorkflowService::V1::PollActivityExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollActivityExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollActivityExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollActivityExecutionRequest, 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::WorkflowService::V1::PollActivityExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + outcome: T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionOutcome) + ).void + end + def initialize( + run_id: "", + outcome: nil + ) + end + + # The run ID of the activity, useful when run_id was not specified in the request. + sig { returns(String) } + def run_id + end + + # The run ID of the activity, useful when run_id was not specified in the request. + sig { params(value: String).void } + def run_id=(value) + end + + # The run ID of the activity, useful when run_id was not specified in the request. + sig { void } + def clear_run_id + end + + sig { returns(T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionOutcome)) } + def outcome + end + + sig { params(value: T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionOutcome)).void } + def outcome=(value) + end + + sig { void } + def clear_outcome + 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::WorkflowService::V1::PollActivityExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollActivityExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollActivityExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollActivityExecutionResponse, 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::WorkflowService::V1::ListActivityExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Max number of executions to return per page. + sig { returns(Integer) } + def page_size + end + + # Max number of executions to return per page. + sig { params(value: Integer).void } + def page_size=(value) + end + + # Max number of executions to return per page. + sig { void } + def clear_page_size + end + + # Token returned in ListActivityExecutionsResponse. + sig { returns(String) } + def next_page_token + end + + # Token returned in ListActivityExecutionsResponse. + sig { params(value: String).void } + def next_page_token=(value) + end + + # Token returned in ListActivityExecutionsResponse. + sig { void } + def clear_next_page_token + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { returns(String) } + def query + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { params(value: String).void } + def query=(value) + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { void } + def clear_query + 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::WorkflowService::V1::ListActivityExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListActivityExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListActivityExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListActivityExecutionsRequest, 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::WorkflowService::V1::ListActivityExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + executions: T.nilable(T::Array[T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionListInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + executions: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Activity::V1::ActivityExecutionListInfo)]) } + def executions + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def executions=(value) + end + + sig { void } + def clear_executions + end + + # Token to use to fetch the next page. If empty, there is no next page. + sig { returns(String) } + def next_page_token + end + + # Token to use to fetch the next page. If empty, there is no next page. + sig { params(value: String).void } + def next_page_token=(value) + end + + # Token to use to fetch the next page. If empty, there is no next page. + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListActivityExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListActivityExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListActivityExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListActivityExecutionsResponse, 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::WorkflowService::V1::StartNexusOperationExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + identity: T.nilable(String), + request_id: T.nilable(String), + operation_id: T.nilable(String), + endpoint: T.nilable(String), + service: T.nilable(String), + operation: T.nilable(String), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + input: T.nilable(Temporalio::Api::Common::V1::Payload), + id_reuse_policy: T.nilable(T.any(Symbol, String, Integer)), + id_conflict_policy: T.nilable(T.any(Symbol, String, Integer)), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + nexus_header: T.nilable(T::Hash[String, String]), + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata) + ).void + end + def initialize( + namespace: "", + identity: "", + request_id: "", + operation_id: "", + endpoint: "", + service: "", + operation: "", + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + input: nil, + id_reuse_policy: :NEXUS_OPERATION_ID_REUSE_POLICY_UNSPECIFIED, + id_conflict_policy: :NEXUS_OPERATION_ID_CONFLICT_POLICY_UNSPECIFIED, + search_attributes: nil, + nexus_header: ::Google::Protobuf::Map.new(:string, :string), + user_metadata: nil + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # A unique identifier for this caller-side start request. Typically UUIDv4. +# StartOperation requests sent to the handler will use a server-generated request ID. + sig { returns(String) } + def request_id + end + + # A unique identifier for this caller-side start request. Typically UUIDv4. +# StartOperation requests sent to the handler will use a server-generated request ID. + sig { params(value: String).void } + def request_id=(value) + end + + # A unique identifier for this caller-side start request. Typically UUIDv4. +# StartOperation requests sent to the handler will use a server-generated request ID. + sig { void } + def clear_request_id + end + + # Identifier for this operation. This is a caller-side ID, distinct from any internal +# operation identifiers generated by the handler. Must be unique among operations in the +# same namespace, subject to the rules imposed by id_reuse_policy and id_conflict_policy. + sig { returns(String) } + def operation_id + end + + # Identifier for this operation. This is a caller-side ID, distinct from any internal +# operation identifiers generated by the handler. Must be unique among operations in the +# same namespace, subject to the rules imposed by id_reuse_policy and id_conflict_policy. + sig { params(value: String).void } + def operation_id=(value) + end + + # Identifier for this operation. This is a caller-side ID, distinct from any internal +# operation identifiers generated by the handler. Must be unique among operations in the +# same namespace, subject to the rules imposed by id_reuse_policy and id_conflict_policy. + sig { void } + def clear_operation_id + end + + # Endpoint name, resolved to a URL via the cluster's endpoint registry. + sig { returns(String) } + def endpoint + end + + # Endpoint name, resolved to a URL via the cluster's endpoint registry. + sig { params(value: String).void } + def endpoint=(value) + end + + # Endpoint name, resolved to a URL via the cluster's endpoint registry. + sig { void } + def clear_endpoint + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Operation name. + sig { returns(String) } + def operation + end + + # Operation name. + sig { params(value: String).void } + def operation=(value) + end + + # Operation name. + sig { void } + def clear_operation + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- 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_close_timeout + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- 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_close_timeout=(value) + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_schedule_to_close_timeout + end + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. +# If not set or zero, no schedule-to-start timeout is enforced. +# (-- 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 + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. +# If not set or zero, no schedule-to-start timeout is enforced. +# (-- 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 + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. +# If not set or zero, no schedule-to-start timeout is enforced. +# (-- 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 + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. +# (-- 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 start_to_close_timeout=(value) + end + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "to" is used to indicate interval. --) + sig { void } + def clear_start_to_close_timeout + end + + # Serialized input to the operation. Passed as the request payload. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def input + end + + # Serialized input to the operation. Passed as the request payload. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def input=(value) + end + + # Serialized input to the operation. Passed as the request payload. + sig { void } + def clear_input + end + + # Defines whether to allow re-using the operation id from a previously *closed* operation. +# The default policy is NEXUS_OPERATION_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { returns(T.any(Symbol, Integer)) } + def id_reuse_policy + end + + # Defines whether to allow re-using the operation id from a previously *closed* operation. +# The default policy is NEXUS_OPERATION_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def id_reuse_policy=(value) + end + + # Defines whether to allow re-using the operation id from a previously *closed* operation. +# The default policy is NEXUS_OPERATION_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { void } + def clear_id_reuse_policy + end + + # Defines how to resolve an operation id conflict with a *running* operation. +# The default policy is NEXUS_OPERATION_ID_CONFLICT_POLICY_FAIL. + sig { returns(T.any(Symbol, Integer)) } + def id_conflict_policy + end + + # Defines how to resolve an operation id conflict with a *running* operation. +# The default policy is NEXUS_OPERATION_ID_CONFLICT_POLICY_FAIL. + sig { params(value: T.any(Symbol, String, Integer)).void } + def id_conflict_policy=(value) + end + + # Defines how to resolve an operation id conflict with a *running* operation. +# The default policy is NEXUS_OPERATION_ID_CONFLICT_POLICY_FAIL. + sig { void } + def clear_id_conflict_policy + end + + # Search attributes for indexing. + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # Search attributes for indexing. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # Search attributes for indexing. + sig { void } + def clear_search_attributes + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in workflow history and +# transmitted to external services as-is. +# This is useful for propagating tracing information. +# Note these headers are not the same as Temporal headers on internal activities and child workflows, these are +# transmitted to Nexus operations that may be external and are not traditional payloads. + sig { returns(T::Hash[String, String]) } + def nexus_header + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in workflow history and +# transmitted to external services as-is. +# This is useful for propagating tracing information. +# Note these headers are not the same as Temporal headers on internal activities and child workflows, these are +# transmitted to Nexus operations that may be external and are not traditional payloads. + sig { params(value: ::Google::Protobuf::Map).void } + def nexus_header=(value) + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in workflow history and +# transmitted to external services as-is. +# This is useful for propagating tracing information. +# Note these headers are not the same as Temporal headers on internal activities and child workflows, these are +# transmitted to Nexus operations that may be external and are not traditional payloads. + sig { void } + def clear_nexus_header + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the operation. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the operation. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # Metadata for use by user interfaces to display the fixed as-of-start summary and details of the operation. + sig { void } + def clear_user_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::WorkflowService::V1::StartNexusOperationExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartNexusOperationExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StartNexusOperationExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartNexusOperationExecutionRequest, 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::WorkflowService::V1::StartNexusOperationExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + started: T.nilable(T::Boolean) + ).void + end + def initialize( + run_id: "", + started: false + ) + end + + # The run ID of the operation that was started - or used (via NEXUS_OPERATION_ID_CONFLICT_POLICY_USE_EXISTING). + sig { returns(String) } + def run_id + end + + # The run ID of the operation that was started - or used (via NEXUS_OPERATION_ID_CONFLICT_POLICY_USE_EXISTING). + sig { params(value: String).void } + def run_id=(value) + end + + # The run ID of the operation that was started - or used (via NEXUS_OPERATION_ID_CONFLICT_POLICY_USE_EXISTING). + sig { void } + def clear_run_id + end + + # If true, a new operation was started. + sig { returns(T::Boolean) } + def started + end + + # If true, a new operation was started. + sig { params(value: T::Boolean).void } + def started=(value) + end + + # If true, a new operation was started. + sig { void } + def clear_started + 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::WorkflowService::V1::StartNexusOperationExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartNexusOperationExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::StartNexusOperationExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::StartNexusOperationExecutionResponse, 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::WorkflowService::V1::DescribeNexusOperationExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + operation_id: T.nilable(String), + run_id: T.nilable(String), + include_input: T.nilable(T::Boolean), + include_outcome: T.nilable(T::Boolean), + long_poll_token: T.nilable(String) + ).void + end + def initialize( + namespace: "", + operation_id: "", + run_id: "", + include_input: false, + include_outcome: false, + long_poll_token: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def operation_id + end + + sig { params(value: String).void } + def operation_id=(value) + end + + sig { void } + def clear_operation_id + end + + # Operation run ID. If empty the request targets the latest run. + sig { returns(String) } + def run_id + end + + # Operation run ID. If empty the request targets the latest run. + sig { params(value: String).void } + def run_id=(value) + end + + # Operation run ID. If empty the request targets the latest run. + sig { void } + def clear_run_id + end + + # Include the input field in the response. + sig { returns(T::Boolean) } + def include_input + end + + # Include the input field in the response. + sig { params(value: T::Boolean).void } + def include_input=(value) + end + + # Include the input field in the response. + sig { void } + def clear_include_input + end + + # Include the outcome (result/failure) in the response if the operation has completed. + sig { returns(T::Boolean) } + def include_outcome + end + + # Include the outcome (result/failure) in the response if the operation has completed. + sig { params(value: T::Boolean).void } + def include_outcome=(value) + end + + # Include the outcome (result/failure) in the response if the operation has completed. + sig { void } + def clear_include_outcome + end + + # Token from a previous DescribeNexusOperationExecutionResponse. If present, this RPC will long-poll until operation +# state changes from the state encoded in this token. If absent, return current state immediately. +# If present, run_id must also be present. +# Note that operation state may change multiple times between requests, therefore it is not +# guaranteed that a client making a sequence of long-poll requests will see a complete +# sequence of state changes. + sig { returns(String) } + def long_poll_token + end + + # Token from a previous DescribeNexusOperationExecutionResponse. If present, this RPC will long-poll until operation +# state changes from the state encoded in this token. If absent, return current state immediately. +# If present, run_id must also be present. +# Note that operation state may change multiple times between requests, therefore it is not +# guaranteed that a client making a sequence of long-poll requests will see a complete +# sequence of state changes. + sig { params(value: String).void } + def long_poll_token=(value) + end + + # Token from a previous DescribeNexusOperationExecutionResponse. If present, this RPC will long-poll until operation +# state changes from the state encoded in this token. If absent, return current state immediately. +# If present, run_id must also be present. +# Note that operation state may change multiple times between requests, therefore it is not +# guaranteed that a client making a sequence of long-poll requests will see a complete +# sequence of state changes. + sig { void } + def clear_long_poll_token + 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::WorkflowService::V1::DescribeNexusOperationExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeNexusOperationExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeNexusOperationExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeNexusOperationExecutionRequest, 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::WorkflowService::V1::DescribeNexusOperationExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + info: T.nilable(Temporalio::Api::Nexus::V1::NexusOperationExecutionInfo), + input: T.nilable(Temporalio::Api::Common::V1::Payload), + result: T.nilable(Temporalio::Api::Common::V1::Payload), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + long_poll_token: T.nilable(String) + ).void + end + def initialize( + run_id: "", + info: nil, + input: nil, + result: nil, + failure: nil, + long_poll_token: "" + ) + end + + # The run ID of the operation, useful when run_id was not specified in the request. + sig { returns(String) } + def run_id + end + + # The run ID of the operation, useful when run_id was not specified in the request. + sig { params(value: String).void } + def run_id=(value) + end + + # The run ID of the operation, useful when run_id was not specified in the request. + sig { void } + def clear_run_id + end + + # Information about the operation. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::NexusOperationExecutionInfo)) } + def info + end + + # Information about the operation. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::NexusOperationExecutionInfo)).void } + def info=(value) + end + + # Information about the operation. + sig { void } + def clear_info + end + + # Serialized operation input, passed as the request payload. +# Only set if include_input was true in the request. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def input + end + + # Serialized operation input, passed as the request payload. +# Only set if include_input was true in the request. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def input=(value) + end + + # Serialized operation input, passed as the request payload. +# Only set if include_input was true in the request. + sig { void } + def clear_input + end + + # The result if the operation completed successfully. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def result + end + + # The result if the operation completed successfully. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def result=(value) + end + + # The result if the operation completed successfully. + sig { void } + def clear_result + end + + # The failure if the operation completed unsuccessfully. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The failure if the operation completed unsuccessfully. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The failure if the operation completed unsuccessfully. + sig { void } + def clear_failure + end + + # Token for follow-on long-poll requests. Absent only if the operation is complete. + sig { returns(String) } + def long_poll_token + end + + # Token for follow-on long-poll requests. Absent only if the operation is complete. + sig { params(value: String).void } + def long_poll_token=(value) + end + + # Token for follow-on long-poll requests. Absent only if the operation is complete. + sig { void } + def clear_long_poll_token + end + + sig { returns(T.nilable(Symbol)) } + def outcome + 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::WorkflowService::V1::DescribeNexusOperationExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeNexusOperationExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeNexusOperationExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeNexusOperationExecutionResponse, 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::WorkflowService::V1::PollNexusOperationExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + operation_id: T.nilable(String), + run_id: T.nilable(String), + wait_stage: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + namespace: "", + operation_id: "", + run_id: "", + wait_stage: :NEXUS_OPERATION_WAIT_STAGE_UNSPECIFIED + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def operation_id + end + + sig { params(value: String).void } + def operation_id=(value) + end + + sig { void } + def clear_operation_id + end + + # Operation run ID. If empty the request targets the latest run. + sig { returns(String) } + def run_id + end + + # Operation run ID. If empty the request targets the latest run. + sig { params(value: String).void } + def run_id=(value) + end + + # Operation run ID. If empty the request targets the latest run. + sig { void } + def clear_run_id + end + + # Stage to wait for. The operation may be in a more advanced stage when the poll is unblocked. + sig { returns(T.any(Symbol, Integer)) } + def wait_stage + end + + # Stage to wait for. The operation may be in a more advanced stage when the poll is unblocked. + sig { params(value: T.any(Symbol, String, Integer)).void } + def wait_stage=(value) + end + + # Stage to wait for. The operation may be in a more advanced stage when the poll is unblocked. + sig { void } + def clear_wait_stage + 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::WorkflowService::V1::PollNexusOperationExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollNexusOperationExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollNexusOperationExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollNexusOperationExecutionRequest, 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::WorkflowService::V1::PollNexusOperationExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + wait_stage: T.nilable(T.any(Symbol, String, Integer)), + operation_token: T.nilable(String), + result: T.nilable(Temporalio::Api::Common::V1::Payload), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + run_id: "", + wait_stage: :NEXUS_OPERATION_WAIT_STAGE_UNSPECIFIED, + operation_token: "", + result: nil, + failure: nil + ) + end + + # The run ID of the operation, useful when run_id was not specified in the request. + sig { returns(String) } + def run_id + end + + # The run ID of the operation, useful when run_id was not specified in the request. + sig { params(value: String).void } + def run_id=(value) + end + + # The run ID of the operation, useful when run_id was not specified in the request. + sig { void } + def clear_run_id + end + + # The current stage of the operation. May be more advanced than the stage requested in the poll. + sig { returns(T.any(Symbol, Integer)) } + def wait_stage + end + + # The current stage of the operation. May be more advanced than the stage requested in the poll. + sig { params(value: T.any(Symbol, String, Integer)).void } + def wait_stage=(value) + end + + # The current stage of the operation. May be more advanced than the stage requested in the poll. + sig { void } + def clear_wait_stage + end + + # Operation token. Only populated for asynchronous operations after a successful StartOperation call. + sig { returns(String) } + def operation_token + end + + # Operation token. Only populated for asynchronous operations after a successful StartOperation call. + sig { params(value: String).void } + def operation_token=(value) + end + + # Operation token. Only populated for asynchronous operations after a successful StartOperation call. + sig { void } + def clear_operation_token + end + + # The result if the operation completed successfully. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def result + end + + # The result if the operation completed successfully. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def result=(value) + end + + # The result if the operation completed successfully. + sig { void } + def clear_result + end + + # The failure if the operation completed unsuccessfully. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The failure if the operation completed unsuccessfully. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The failure if the operation completed unsuccessfully. + sig { void } + def clear_failure + end + + sig { returns(T.nilable(Symbol)) } + def outcome + 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::WorkflowService::V1::PollNexusOperationExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollNexusOperationExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::PollNexusOperationExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::PollNexusOperationExecutionResponse, 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::WorkflowService::V1::ListNexusOperationExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + page_size: 0, + next_page_token: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Max number of operations to return per page. + sig { returns(Integer) } + def page_size + end + + # Max number of operations to return per page. + sig { params(value: Integer).void } + def page_size=(value) + end + + # Max number of operations to return per page. + sig { void } + def clear_page_size + end + + # Token returned in ListNexusOperationExecutionsResponse. + sig { returns(String) } + def next_page_token + end + + # Token returned in ListNexusOperationExecutionsResponse. + sig { params(value: String).void } + def next_page_token=(value) + end + + # Token returned in ListNexusOperationExecutionsResponse. + sig { void } + def clear_next_page_token + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. +# Search attributes that are avaialble for Nexus operations include: +# - OperationId +# - RunId +# - Endpoint +# - Service +# - Operation +# - RequestId +# - StartTime +# - ExecutionTime +# - CloseTime +# - ExecutionStatus +# - ExecutionDuration +# - StateTransitionCount + sig { returns(String) } + def query + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. +# Search attributes that are avaialble for Nexus operations include: +# - OperationId +# - RunId +# - Endpoint +# - Service +# - Operation +# - RequestId +# - StartTime +# - ExecutionTime +# - CloseTime +# - ExecutionStatus +# - ExecutionDuration +# - StateTransitionCount + sig { params(value: String).void } + def query=(value) + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. +# Search attributes that are avaialble for Nexus operations include: +# - OperationId +# - RunId +# - Endpoint +# - Service +# - Operation +# - RequestId +# - StartTime +# - ExecutionTime +# - CloseTime +# - ExecutionStatus +# - ExecutionDuration +# - StateTransitionCount + sig { void } + def clear_query + 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::WorkflowService::V1::ListNexusOperationExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListNexusOperationExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListNexusOperationExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListNexusOperationExecutionsRequest, 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::WorkflowService::V1::ListNexusOperationExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + operations: T.nilable(T::Array[T.nilable(Temporalio::Api::Nexus::V1::NexusOperationExecutionListInfo)]), + next_page_token: T.nilable(String) + ).void + end + def initialize( + operations: [], + next_page_token: "" + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Nexus::V1::NexusOperationExecutionListInfo)]) } + def operations + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def operations=(value) + end + + sig { void } + def clear_operations + end + + # Token to use to fetch the next page. If empty, there is no next page. + sig { returns(String) } + def next_page_token + end + + # Token to use to fetch the next page. If empty, there is no next page. + sig { params(value: String).void } + def next_page_token=(value) + end + + # Token to use to fetch the next page. If empty, there is no next page. + sig { void } + def clear_next_page_token + 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::WorkflowService::V1::ListNexusOperationExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListNexusOperationExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListNexusOperationExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListNexusOperationExecutionsResponse, 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::WorkflowService::V1::CountActivityExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { returns(String) } + def query + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { params(value: String).void } + def query=(value) + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. + sig { void } + def clear_query + 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::WorkflowService::V1::CountActivityExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountActivityExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsRequest, 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::WorkflowService::V1::CountActivityExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + count: T.nilable(Integer), + groups: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse::AggregationGroup)]) + ).void + end + def initialize( + count: 0, + groups: [] + ) + end + + # If `query` is not grouping by any field, the count is an approximate number +# of activities that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of activities matching the query. + sig { returns(Integer) } + def count + end + + # If `query` is not grouping by any field, the count is an approximate number +# of activities that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of activities matching the query. + sig { params(value: Integer).void } + def count=(value) + end + + # If `query` is not grouping by any field, the count is an approximate number +# of activities that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of activities matching the query. + sig { void } + def clear_count + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse::AggregationGroup)]) } + def groups + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def groups=(value) + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { void } + def clear_groups + 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::WorkflowService::V1::CountActivityExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse, 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::WorkflowService::V1::CountNexusOperationExecutionsRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + query: T.nilable(String) + ).void + end + def initialize( + namespace: "", + query: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. +# See also ListNexusOperationExecutionsRequest for search attributes available for Nexus operations. + sig { returns(String) } + def query + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. +# See also ListNexusOperationExecutionsRequest for search attributes available for Nexus operations. + sig { params(value: String).void } + def query=(value) + end + + # Visibility query, see https://docs.temporal.io/list-filter for the syntax. +# See also ListNexusOperationExecutionsRequest for search attributes available for Nexus operations. + sig { void } + def clear_query + 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::WorkflowService::V1::CountNexusOperationExecutionsRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsRequest, 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::WorkflowService::V1::CountNexusOperationExecutionsResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + count: T.nilable(Integer), + groups: T.nilable(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse::AggregationGroup)]) + ).void + end + def initialize( + count: 0, + groups: [] + ) + end + + # If `query` is not grouping by any field, the count is an approximate number +# of operations that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of operations matching the query. + sig { returns(Integer) } + def count + end + + # If `query` is not grouping by any field, the count is an approximate number +# of operations that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of operations matching the query. + sig { params(value: Integer).void } + def count=(value) + end + + # If `query` is not grouping by any field, the count is an approximate number +# of operations that match the query. +# If `query` is grouping by a field, the count is simply the sum of the counts +# of the groups returned in the response. This number can be smaller than the +# total number of operations matching the query. + sig { void } + def clear_count + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { returns(T::Array[T.nilable(Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse::AggregationGroup)]) } + def groups + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def groups=(value) + end + + # Contains the groups if the request is grouping by a field. +# The list might not be complete, and the counts of each group is approximate. + sig { void } + def clear_groups + 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::WorkflowService::V1::CountNexusOperationExecutionsResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse, 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::WorkflowService::V1::RequestCancelActivityExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + activity_id: T.nilable(String), + run_id: T.nilable(String), + identity: T.nilable(String), + request_id: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + namespace: "", + activity_id: "", + run_id: "", + identity: "", + request_id: "", + reason: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { returns(String) } + def run_id + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { params(value: String).void } + def run_id=(value) + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { void } + def clear_run_id + end + + # The identity of the worker/client. + sig { returns(String) } + def identity + end + + # The identity of the worker/client. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client. + sig { void } + def clear_identity + end + + # Used to de-dupe cancellation requests. + sig { returns(String) } + def request_id + end + + # Used to de-dupe cancellation requests. + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe cancellation requests. + sig { void } + def clear_request_id + end + + # Reason for requesting the cancellation, recorded and available via the PollActivityExecution API. +# Not propagated to a worker if an activity attempt is currently running. + sig { returns(String) } + def reason + end + + # Reason for requesting the cancellation, recorded and available via the PollActivityExecution API. +# Not propagated to a worker if an activity attempt is currently running. + sig { params(value: String).void } + def reason=(value) + end + + # Reason for requesting the cancellation, recorded and available via the PollActivityExecution API. +# Not propagated to a worker if an activity attempt is currently running. + sig { void } + def clear_reason + 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::WorkflowService::V1::RequestCancelActivityExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionRequest, 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::WorkflowService::V1::RequestCancelActivityExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RequestCancelActivityExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionResponse, 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::WorkflowService::V1::TerminateActivityExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + activity_id: T.nilable(String), + run_id: T.nilable(String), + identity: T.nilable(String), + request_id: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + namespace: "", + activity_id: "", + run_id: "", + identity: "", + request_id: "", + reason: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { returns(String) } + def run_id + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { params(value: String).void } + def run_id=(value) + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { void } + def clear_run_id + end + + # The identity of the worker/client. + sig { returns(String) } + def identity + end + + # The identity of the worker/client. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the worker/client. + sig { void } + def clear_identity + end + + # Used to de-dupe termination requests. + sig { returns(String) } + def request_id + end + + # Used to de-dupe termination requests. + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe termination requests. + sig { void } + def clear_request_id + end + + # Reason for requesting the termination, recorded in in the activity's result failure outcome. + sig { returns(String) } + def reason + end + + # Reason for requesting the termination, recorded in in the activity's result failure outcome. + sig { params(value: String).void } + def reason=(value) + end + + # Reason for requesting the termination, recorded in in the activity's result failure outcome. + sig { void } + def clear_reason + 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::WorkflowService::V1::TerminateActivityExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionRequest, 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::WorkflowService::V1::TerminateActivityExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::TerminateActivityExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionResponse, 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::WorkflowService::V1::DeleteActivityExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + activity_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + activity_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { returns(String) } + def run_id + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { params(value: String).void } + def run_id=(value) + end + + # Activity run ID, targets the latest run if run_id is empty. + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionRequest, 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::WorkflowService::V1::DeleteActivityExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::DeleteActivityExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionResponse, 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::WorkflowService::V1::RequestCancelNexusOperationExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + operation_id: T.nilable(String), + run_id: T.nilable(String), + identity: T.nilable(String), + request_id: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + namespace: "", + operation_id: "", + run_id: "", + identity: "", + request_id: "", + reason: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def operation_id + end + + sig { params(value: String).void } + def operation_id=(value) + end + + sig { void } + def clear_operation_id + end + + # Operation run ID, targets the latest run if empty. + sig { returns(String) } + def run_id + end + + # Operation run ID, targets the latest run if empty. + sig { params(value: String).void } + def run_id=(value) + end + + # Operation run ID, targets the latest run if empty. + sig { void } + def clear_run_id + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Used to de-dupe cancellation requests. + sig { returns(String) } + def request_id + end + + # Used to de-dupe cancellation requests. + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe cancellation requests. + sig { void } + def clear_request_id + end + + # Reason for requesting the cancellation, recorded and available via the DescribeNexusOperationExecution API. + sig { returns(String) } + def reason + end + + # Reason for requesting the cancellation, recorded and available via the DescribeNexusOperationExecution API. + sig { params(value: String).void } + def reason=(value) + end + + # Reason for requesting the cancellation, recorded and available via the DescribeNexusOperationExecution API. + sig { void } + def clear_reason + 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::WorkflowService::V1::RequestCancelNexusOperationExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelNexusOperationExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RequestCancelNexusOperationExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelNexusOperationExecutionRequest, 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::WorkflowService::V1::RequestCancelNexusOperationExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::RequestCancelNexusOperationExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelNexusOperationExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RequestCancelNexusOperationExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RequestCancelNexusOperationExecutionResponse, 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::WorkflowService::V1::TerminateNexusOperationExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + operation_id: T.nilable(String), + run_id: T.nilable(String), + identity: T.nilable(String), + request_id: T.nilable(String), + reason: T.nilable(String) + ).void + end + def initialize( + namespace: "", + operation_id: "", + run_id: "", + identity: "", + request_id: "", + reason: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def operation_id + end + + sig { params(value: String).void } + def operation_id=(value) + end + + sig { void } + def clear_operation_id + end + + # Operation run ID, targets the latest run if empty. + sig { returns(String) } + def run_id + end + + # Operation run ID, targets the latest run if empty. + sig { params(value: String).void } + def run_id=(value) + end + + # Operation run ID, targets the latest run if empty. + sig { void } + def clear_run_id + end + + # The identity of the client who initiated this request. + sig { returns(String) } + def identity + end + + # The identity of the client who initiated this request. + sig { params(value: String).void } + def identity=(value) + end + + # The identity of the client who initiated this request. + sig { void } + def clear_identity + end + + # Used to de-dupe termination requests. + sig { returns(String) } + def request_id + end + + # Used to de-dupe termination requests. + sig { params(value: String).void } + def request_id=(value) + end + + # Used to de-dupe termination requests. + sig { void } + def clear_request_id + end + + # Reason for requesting the termination, recorded in the operation's result failure outcome. + sig { returns(String) } + def reason + end + + # Reason for requesting the termination, recorded in the operation's result failure outcome. + sig { params(value: String).void } + def reason=(value) + end + + # Reason for requesting the termination, recorded in the operation's result failure outcome. + sig { void } + def clear_reason + 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::WorkflowService::V1::TerminateNexusOperationExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionRequest, 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::WorkflowService::V1::TerminateNexusOperationExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::TerminateNexusOperationExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionResponse, 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::WorkflowService::V1::DeleteNexusOperationExecutionRequest + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + operation_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + operation_id: "", + run_id: "" + ) + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def operation_id + end + + sig { params(value: String).void } + def operation_id=(value) + end + + sig { void } + def clear_operation_id + end + + # Operation run ID, targets the latest run if empty. + sig { returns(String) } + def run_id + end + + # Operation run ID, targets the latest run if empty. + sig { params(value: String).void } + def run_id=(value) + end + + # Operation run ID, targets the latest run if empty. + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionRequest) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionRequest).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionRequest) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionRequest, 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::WorkflowService::V1::DeleteNexusOperationExecutionResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::WorkflowService::V1::DeleteNexusOperationExecutionResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# SDK capability details. +class Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest::Capabilities + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + discard_speculative_workflow_task_with_events: T.nilable(T::Boolean) + ).void + end + def initialize( + discard_speculative_workflow_task_with_events: false + ) + end + + # True if the SDK can handle speculative workflow task with command events. If true, the +# server may choose, at its discretion, to discard a speculative workflow task even if that +# speculative task included command events the SDK had not previously processed. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "with" used to describe the workflow task. --) + sig { returns(T::Boolean) } + def discard_speculative_workflow_task_with_events + end + + # True if the SDK can handle speculative workflow task with command events. If true, the +# server may choose, at its discretion, to discard a speculative workflow task even if that +# speculative task included command events the SDK had not previously processed. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "with" used to describe the workflow task. --) + sig { params(value: T::Boolean).void } + def discard_speculative_workflow_task_with_events=(value) + end + + # True if the SDK can handle speculative workflow task with command events. If true, the +# server may choose, at its discretion, to discard a speculative workflow task even if that +# speculative task included command events the SDK had not previously processed. +# +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "with" used to describe the workflow task. --) + sig { void } + def clear_discard_speculative_workflow_task_with_events + 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::WorkflowService::V1::RespondWorkflowTaskCompletedRequest::Capabilities) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest::Capabilities).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest::Capabilities) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest::Capabilities, 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::WorkflowService::V1::CountWorkflowExecutionsResponse::AggregationGroup + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_values: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + count: T.nilable(Integer) + ).void + end + def initialize( + group_values: [], + count: 0 + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def group_values + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def group_values=(value) + end + + sig { void } + def clear_group_values + end + + sig { returns(Integer) } + def count + end + + sig { params(value: Integer).void } + def count=(value) + end + + sig { void } + def clear_count + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse::AggregationGroup) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse::AggregationGroup).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse::AggregationGroup) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse::AggregationGroup, 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::WorkflowService::V1::DescribeTaskQueueResponse::EffectiveRateLimit + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + requests_per_second: T.nilable(Float), + rate_limit_source: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + requests_per_second: 0.0, + rate_limit_source: :RATE_LIMIT_SOURCE_UNSPECIFIED + ) + end + + # The effective rate limit for the task queue. + sig { returns(Float) } + def requests_per_second + end + + # The effective rate limit for the task queue. + sig { params(value: Float).void } + def requests_per_second=(value) + end + + # The effective rate limit for the task queue. + sig { void } + def clear_requests_per_second + end + + # Source of the RateLimit Configuration,which can be one of the following values: +# - SOURCE_API: The rate limit that is set via the TaskQueueConfig api. +# - SOURCE_WORKER: The rate limit is the value set using the workerOptions in TaskQueueActivitiesPerSecond. +# - SOURCE_SYSTEM: The rate limit is the default value set by the system + sig { returns(T.any(Symbol, Integer)) } + def rate_limit_source + end + + # Source of the RateLimit Configuration,which can be one of the following values: +# - SOURCE_API: The rate limit that is set via the TaskQueueConfig api. +# - SOURCE_WORKER: The rate limit is the value set using the workerOptions in TaskQueueActivitiesPerSecond. +# - SOURCE_SYSTEM: The rate limit is the default value set by the system + sig { params(value: T.any(Symbol, String, Integer)).void } + def rate_limit_source=(value) + end + + # Source of the RateLimit Configuration,which can be one of the following values: +# - SOURCE_API: The rate limit that is set via the TaskQueueConfig api. +# - SOURCE_WORKER: The rate limit is the value set using the workerOptions in TaskQueueActivitiesPerSecond. +# - SOURCE_SYSTEM: The rate limit is the default value set by the system + sig { void } + def clear_rate_limit_source + 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::WorkflowService::V1::DescribeTaskQueueResponse::EffectiveRateLimit) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse::EffectiveRateLimit).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse::EffectiveRateLimit) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse::EffectiveRateLimit, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# System capability details. +class Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse::Capabilities + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + signal_and_query_header: T.nilable(T::Boolean), + internal_error_differentiation: T.nilable(T::Boolean), + activity_failure_include_heartbeat: T.nilable(T::Boolean), + supports_schedules: T.nilable(T::Boolean), + encoded_failure_attributes: T.nilable(T::Boolean), + build_id_based_versioning: T.nilable(T::Boolean), + upsert_memo: T.nilable(T::Boolean), + eager_workflow_start: T.nilable(T::Boolean), + sdk_metadata: T.nilable(T::Boolean), + count_group_by_execution_status: T.nilable(T::Boolean), + nexus: T.nilable(T::Boolean), + server_scaled_deployments: T.nilable(T::Boolean) + ).void + end + def initialize( + signal_and_query_header: false, + internal_error_differentiation: false, + activity_failure_include_heartbeat: false, + supports_schedules: false, + encoded_failure_attributes: false, + build_id_based_versioning: false, + upsert_memo: false, + eager_workflow_start: false, + sdk_metadata: false, + count_group_by_execution_status: false, + nexus: false, + server_scaled_deployments: false + ) + end + + # True if signal and query headers are supported. + sig { returns(T::Boolean) } + def signal_and_query_header + end + + # True if signal and query headers are supported. + sig { params(value: T::Boolean).void } + def signal_and_query_header=(value) + end + + # True if signal and query headers are supported. + sig { void } + def clear_signal_and_query_header + end + + # True if internal errors are differentiated from other types of errors for purposes of +# retrying non-internal errors. +# +# When unset/false, clients retry all failures. When true, clients should only retry +# non-internal errors. + sig { returns(T::Boolean) } + def internal_error_differentiation + end + + # True if internal errors are differentiated from other types of errors for purposes of +# retrying non-internal errors. +# +# When unset/false, clients retry all failures. When true, clients should only retry +# non-internal errors. + sig { params(value: T::Boolean).void } + def internal_error_differentiation=(value) + end + + # True if internal errors are differentiated from other types of errors for purposes of +# retrying non-internal errors. +# +# When unset/false, clients retry all failures. When true, clients should only retry +# non-internal errors. + sig { void } + def clear_internal_error_differentiation + end + + # True if RespondActivityTaskFailed API supports including heartbeat details + sig { returns(T::Boolean) } + def activity_failure_include_heartbeat + end + + # True if RespondActivityTaskFailed API supports including heartbeat details + sig { params(value: T::Boolean).void } + def activity_failure_include_heartbeat=(value) + end + + # True if RespondActivityTaskFailed API supports including heartbeat details + sig { void } + def clear_activity_failure_include_heartbeat + end + + # Supports scheduled workflow features. + sig { returns(T::Boolean) } + def supports_schedules + end + + # Supports scheduled workflow features. + sig { params(value: T::Boolean).void } + def supports_schedules=(value) + end + + # Supports scheduled workflow features. + sig { void } + def clear_supports_schedules + end + + # True if server uses protos that include temporal.api.failure.v1.Failure.encoded_attributes + sig { returns(T::Boolean) } + def encoded_failure_attributes + end + + # True if server uses protos that include temporal.api.failure.v1.Failure.encoded_attributes + sig { params(value: T::Boolean).void } + def encoded_failure_attributes=(value) + end + + # True if server uses protos that include temporal.api.failure.v1.Failure.encoded_attributes + sig { void } + def clear_encoded_failure_attributes + end + + # True if server supports dispatching Workflow and Activity tasks based on a worker's build_id +# (see: +# https://github.com/temporalio/proposals/blob/a123af3b559f43db16ea6dd31870bfb754c4dc5e/versioning/worker-versions.md) + sig { returns(T::Boolean) } + def build_id_based_versioning + end + + # True if server supports dispatching Workflow and Activity tasks based on a worker's build_id +# (see: +# https://github.com/temporalio/proposals/blob/a123af3b559f43db16ea6dd31870bfb754c4dc5e/versioning/worker-versions.md) + sig { params(value: T::Boolean).void } + def build_id_based_versioning=(value) + end + + # True if server supports dispatching Workflow and Activity tasks based on a worker's build_id +# (see: +# https://github.com/temporalio/proposals/blob/a123af3b559f43db16ea6dd31870bfb754c4dc5e/versioning/worker-versions.md) + sig { void } + def clear_build_id_based_versioning + end + + # True if server supports upserting workflow memo + sig { returns(T::Boolean) } + def upsert_memo + end + + # True if server supports upserting workflow memo + sig { params(value: T::Boolean).void } + def upsert_memo=(value) + end + + # True if server supports upserting workflow memo + sig { void } + def clear_upsert_memo + end + + # True if server supports eager workflow task dispatching for the StartWorkflowExecution API + sig { returns(T::Boolean) } + def eager_workflow_start + end + + # True if server supports eager workflow task dispatching for the StartWorkflowExecution API + sig { params(value: T::Boolean).void } + def eager_workflow_start=(value) + end + + # True if server supports eager workflow task dispatching for the StartWorkflowExecution API + sig { void } + def clear_eager_workflow_start + end + + # True if the server knows about the sdk metadata field on WFT completions and will record +# it in history + sig { returns(T::Boolean) } + def sdk_metadata + end + + # True if the server knows about the sdk metadata field on WFT completions and will record +# it in history + sig { params(value: T::Boolean).void } + def sdk_metadata=(value) + end + + # True if the server knows about the sdk metadata field on WFT completions and will record +# it in history + sig { void } + def clear_sdk_metadata + end + + # True if the server supports count group by execution status +# (-- api-linter: core::0140::prepositions=disabled --) + sig { returns(T::Boolean) } + def count_group_by_execution_status + end + + # True if the server supports count group by execution status +# (-- api-linter: core::0140::prepositions=disabled --) + sig { params(value: T::Boolean).void } + def count_group_by_execution_status=(value) + end + + # True if the server supports count group by execution status +# (-- api-linter: core::0140::prepositions=disabled --) + sig { void } + def clear_count_group_by_execution_status + end + + # True if the server supports Nexus operations. +# This flag is dependent both on server version and for Nexus to be enabled via server configuration. + sig { returns(T::Boolean) } + def nexus + end + + # True if the server supports Nexus operations. +# This flag is dependent both on server version and for Nexus to be enabled via server configuration. + sig { params(value: T::Boolean).void } + def nexus=(value) + end + + # True if the server supports Nexus operations. +# This flag is dependent both on server version and for Nexus to be enabled via server configuration. + sig { void } + def clear_nexus + end + + # True if the server supports server-scaled deployments. +# This flag is dependent both on server version and for server-scaled deployments +# to be enabled via server configuration. + sig { returns(T::Boolean) } + def server_scaled_deployments + end + + # True if the server supports server-scaled deployments. +# This flag is dependent both on server version and for server-scaled deployments +# to be enabled via server configuration. + sig { params(value: T::Boolean).void } + def server_scaled_deployments=(value) + end + + # True if the server supports server-scaled deployments. +# This flag is dependent both on server version and for server-scaled deployments +# to be enabled via server configuration. + sig { void } + def clear_server_scaled_deployments + 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::WorkflowService::V1::GetSystemInfoResponse::Capabilities) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse::Capabilities).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse::Capabilities) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse::Capabilities, 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::WorkflowService::V1::CountSchedulesResponse::AggregationGroup + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_values: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + count: T.nilable(Integer) + ).void + end + def initialize( + group_values: [], + count: 0 + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def group_values + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def group_values=(value) + end + + sig { void } + def clear_group_values + end + + sig { returns(Integer) } + def count + end + + sig { params(value: Integer).void } + def count=(value) + end + + sig { void } + def clear_count + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::WorkflowService::V1::CountSchedulesResponse::AggregationGroup) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountSchedulesResponse::AggregationGroup).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountSchedulesResponse::AggregationGroup) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountSchedulesResponse::AggregationGroup, 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::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::AddNewCompatibleVersion + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + new_build_id: T.nilable(String), + existing_compatible_build_id: T.nilable(String), + make_set_default: T.nilable(T::Boolean) + ).void + end + def initialize( + new_build_id: "", + existing_compatible_build_id: "", + make_set_default: false + ) + end + + # A new id to be added to an existing compatible set. + sig { returns(String) } + def new_build_id + end + + # A new id to be added to an existing compatible set. + sig { params(value: String).void } + def new_build_id=(value) + end + + # A new id to be added to an existing compatible set. + sig { void } + def clear_new_build_id + end + + # A build id which must already exist in the version sets known by the task queue. The new +# id will be stored in the set containing this id, marking it as compatible with +# the versions within. + sig { returns(String) } + def existing_compatible_build_id + end + + # A build id which must already exist in the version sets known by the task queue. The new +# id will be stored in the set containing this id, marking it as compatible with +# the versions within. + sig { params(value: String).void } + def existing_compatible_build_id=(value) + end + + # A build id which must already exist in the version sets known by the task queue. The new +# id will be stored in the set containing this id, marking it as compatible with +# the versions within. + sig { void } + def clear_existing_compatible_build_id + end + + # When set, establishes the compatible set being targeted as the overall default for the +# queue. If a different set was the current default, the targeted set will replace it as +# the new default. + sig { returns(T::Boolean) } + def make_set_default + end + + # When set, establishes the compatible set being targeted as the overall default for the +# queue. If a different set was the current default, the targeted set will replace it as +# the new default. + sig { params(value: T::Boolean).void } + def make_set_default=(value) + end + + # When set, establishes the compatible set being targeted as the overall default for the +# queue. If a different set was the current default, the targeted set will replace it as +# the new default. + sig { void } + def clear_make_set_default + 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::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::AddNewCompatibleVersion) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::AddNewCompatibleVersion).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::AddNewCompatibleVersion) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::AddNewCompatibleVersion, 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::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::MergeSets + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + primary_set_build_id: T.nilable(String), + secondary_set_build_id: T.nilable(String) + ).void + end + def initialize( + primary_set_build_id: "", + secondary_set_build_id: "" + ) + end + + # A build ID in the set whose default will become the merged set default + sig { returns(String) } + def primary_set_build_id + end + + # A build ID in the set whose default will become the merged set default + sig { params(value: String).void } + def primary_set_build_id=(value) + end + + # A build ID in the set whose default will become the merged set default + sig { void } + def clear_primary_set_build_id + end + + # A build ID in the set which will be merged into the primary set + sig { returns(String) } + def secondary_set_build_id + end + + # A build ID in the set which will be merged into the primary set + sig { params(value: String).void } + def secondary_set_build_id=(value) + end + + # A build ID in the set which will be merged into the primary set + sig { void } + def clear_secondary_set_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::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::MergeSets) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::MergeSets).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::MergeSets) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest::MergeSets, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Inserts the rule to the list of assignment rules for this 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. +class Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::InsertBuildIdAssignmentRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rule_index: T.nilable(Integer), + rule: T.nilable(Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule) + ).void + end + def initialize( + rule_index: 0, + rule: nil + ) + end + + # Use this option to insert the rule in a particular index. By +# default, the new rule is inserted at the beginning of the list +# (index 0). If the given index is too larger the rule will be +# inserted at the end of the list. + sig { returns(Integer) } + def rule_index + end + + # Use this option to insert the rule in a particular index. By +# default, the new rule is inserted at the beginning of the list +# (index 0). If the given index is too larger the rule will be +# inserted at the end of the list. + sig { params(value: Integer).void } + def rule_index=(value) + end + + # Use this option to insert the rule in a particular index. By +# default, the new rule is inserted at the beginning of the list +# (index 0). If the given index is too larger the rule will be +# inserted at the end of the list. + sig { void } + def clear_rule_index + 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 { 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::InsertBuildIdAssignmentRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::InsertBuildIdAssignmentRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::InsertBuildIdAssignmentRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::InsertBuildIdAssignmentRule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Replaces the assignment rule at a given index. +class Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceBuildIdAssignmentRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rule_index: T.nilable(Integer), + rule: T.nilable(Temporalio::Api::TaskQueue::V1::BuildIdAssignmentRule), + force: T.nilable(T::Boolean) + ).void + end + def initialize( + rule_index: 0, + rule: nil, + force: false + ) + end + + sig { returns(Integer) } + def rule_index + end + + sig { params(value: Integer).void } + def rule_index=(value) + end + + sig { void } + def clear_rule_index + 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 + + # By default presence of one unconditional rule is enforced, otherwise +# the replace operation will be rejected. Set `force` to true to +# bypass this validation. An unconditional assignment rule: +# - Has no hint filter +# - Has no ramp + sig { returns(T::Boolean) } + def force + end + + # By default presence of one unconditional rule is enforced, otherwise +# the replace operation will be rejected. Set `force` to true to +# bypass this validation. An unconditional assignment rule: +# - Has no hint filter +# - Has no ramp + sig { params(value: T::Boolean).void } + def force=(value) + end + + # By default presence of one unconditional rule is enforced, otherwise +# the replace operation will be rejected. Set `force` to true to +# bypass this validation. An unconditional assignment rule: +# - Has no hint filter +# - Has no ramp + sig { void } + def clear_force + 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceBuildIdAssignmentRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceBuildIdAssignmentRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceBuildIdAssignmentRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceBuildIdAssignmentRule, 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteBuildIdAssignmentRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rule_index: T.nilable(Integer), + force: T.nilable(T::Boolean) + ).void + end + def initialize( + rule_index: 0, + force: false + ) + end + + sig { returns(Integer) } + def rule_index + end + + sig { params(value: Integer).void } + def rule_index=(value) + end + + sig { void } + def clear_rule_index + end + + # By default presence of one unconditional rule is enforced, otherwise +# the delete operation will be rejected. Set `force` to true to +# bypass this validation. An unconditional assignment rule: +# - Has no hint filter +# - Has no ramp + sig { returns(T::Boolean) } + def force + end + + # By default presence of one unconditional rule is enforced, otherwise +# the delete operation will be rejected. Set `force` to true to +# bypass this validation. An unconditional assignment rule: +# - Has no hint filter +# - Has no ramp + sig { params(value: T::Boolean).void } + def force=(value) + end + + # By default presence of one unconditional rule is enforced, otherwise +# the delete operation will be rejected. Set `force` to true to +# bypass this validation. An unconditional assignment rule: +# - Has no hint filter +# - Has no ramp + sig { void } + def clear_force + 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteBuildIdAssignmentRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteBuildIdAssignmentRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteBuildIdAssignmentRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteBuildIdAssignmentRule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Adds the rule to the list of redirect rules for this Task Queue. There +# can be at most one redirect rule for each distinct Source Build ID. +class Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::AddCompatibleBuildIdRedirectRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rule: T.nilable(Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule) + ).void + end + def initialize( + rule: 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 { 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::AddCompatibleBuildIdRedirectRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::AddCompatibleBuildIdRedirectRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::AddCompatibleBuildIdRedirectRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::AddCompatibleBuildIdRedirectRule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Replaces the routing rule with the given source Build ID. +class Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceCompatibleBuildIdRedirectRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rule: T.nilable(Temporalio::Api::TaskQueue::V1::CompatibleBuildIdRedirectRule) + ).void + end + def initialize( + rule: 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 { 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceCompatibleBuildIdRedirectRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceCompatibleBuildIdRedirectRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceCompatibleBuildIdRedirectRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::ReplaceCompatibleBuildIdRedirectRule, 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteCompatibleBuildIdRedirectRule + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + source_build_id: T.nilable(String) + ).void + end + def initialize( + source_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 + + 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteCompatibleBuildIdRedirectRule) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteCompatibleBuildIdRedirectRule).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteCompatibleBuildIdRedirectRule) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::DeleteCompatibleBuildIdRedirectRule, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# This command is intended to be used to complete the rollout of a Build +# ID and cleanup unnecessary rules possibly created during a gradual +# rollout. Specifically, this command will make the following changes +# atomically: +# 1. Adds an assignment rule (with full ramp) for the target Build ID at +# the end of the list. +# 2. Removes all previously added assignment rules to the given target +# Build ID (if any). +# 3. Removes any fully-ramped assignment rule for other Build IDs. +class Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::CommitBuildId + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + target_build_id: T.nilable(String), + force: T.nilable(T::Boolean) + ).void + end + def initialize( + target_build_id: "", + force: false + ) + 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 + + # To prevent committing invalid Build IDs, we reject the request if no +# pollers has been seen recently for this Build ID. Use the `force` +# option to disable this validation. + sig { returns(T::Boolean) } + def force + end + + # To prevent committing invalid Build IDs, we reject the request if no +# pollers has been seen recently for this Build ID. Use the `force` +# option to disable this validation. + sig { params(value: T::Boolean).void } + def force=(value) + end + + # To prevent committing invalid Build IDs, we reject the request if no +# pollers has been seen recently for this Build ID. Use the `force` +# option to disable this validation. + sig { void } + def clear_force + 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::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::CommitBuildId) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::CommitBuildId).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::CommitBuildId) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest::CommitBuildId, 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::WorkflowService::V1::ExecuteMultiOperationRequest::Operation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_workflow: T.nilable(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionRequest), + update_workflow: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionRequest) + ).void + end + def initialize( + start_workflow: nil, + update_workflow: nil + ) + end + + # Additional restrictions: +# - setting `cron_schedule` is invalid +# - setting `request_eager_execution` is invalid +# - setting `workflow_start_delay` is invalid + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionRequest)) } + def start_workflow + end + + # Additional restrictions: +# - setting `cron_schedule` is invalid +# - setting `request_eager_execution` is invalid +# - setting `workflow_start_delay` is invalid + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionRequest)).void } + def start_workflow=(value) + end + + # Additional restrictions: +# - setting `cron_schedule` is invalid +# - setting `request_eager_execution` is invalid +# - setting `workflow_start_delay` is invalid + sig { void } + def clear_start_workflow + end + + # Additional restrictions: +# - setting `first_execution_run_id` is invalid +# - setting `workflow_execution.run_id` is invalid + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionRequest)) } + def update_workflow + end + + # Additional restrictions: +# - setting `first_execution_run_id` is invalid +# - setting `workflow_execution.run_id` is invalid + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionRequest)).void } + def update_workflow=(value) + end + + # Additional restrictions: +# - setting `first_execution_run_id` is invalid +# - setting `workflow_execution.run_id` is invalid + sig { void } + def clear_update_workflow + end + + sig { returns(T.nilable(Symbol)) } + def operation + 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::WorkflowService::V1::ExecuteMultiOperationRequest::Operation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest::Operation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest::Operation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest::Operation, 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::WorkflowService::V1::ExecuteMultiOperationResponse::Response + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + start_workflow: T.nilable(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionResponse), + update_workflow: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionResponse) + ).void + end + def initialize( + start_workflow: nil, + update_workflow: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionResponse)) } + def start_workflow + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionResponse)).void } + def start_workflow=(value) + end + + sig { void } + def clear_start_workflow + end + + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionResponse)) } + def update_workflow + end + + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionResponse)).void } + def update_workflow=(value) + end + + sig { void } + def clear_update_workflow + end + + sig { returns(T.nilable(Symbol)) } + def response + 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::WorkflowService::V1::ExecuteMultiOperationResponse::Response) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse::Response).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse::Response) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse::Response, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# (-- api-linter: core::0123::resource-annotation=disabled --) +class Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse::VersionTaskQueue + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + type: T.nilable(T.any(Symbol, String, Integer)), + stats: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats), + stats_by_priority_key: T.nilable(T::Hash[Integer, T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)]) + ).void + end + def initialize( + name: "", + type: :TASK_QUEUE_TYPE_UNSPECIFIED, + stats: nil, + stats_by_priority_key: ::Google::Protobuf::Map.new(:int32, :message, Temporalio::Api::TaskQueue::V1::TaskQueueStats) + ) + end + + sig { returns(String) } + def name + end + + sig { params(value: String).void } + def name=(value) + end + + sig { void } + def clear_name + end + + sig { returns(T.any(Symbol, Integer)) } + def type + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def type=(value) + end + + sig { void } + def clear_type + end + + # Only set if `report_task_queue_stats` is set on the request. + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)) } + def stats + end + + # Only set if `report_task_queue_stats` is set on the request. + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)).void } + def stats=(value) + end + + # Only set if `report_task_queue_stats` is set on the request. + sig { void } + def clear_stats + end + + # Task queue stats breakdown by priority key. Only contains actively used priority keys. +# Only set if `report_task_queue_stats` is set to true in the request. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "by" is used to clarify the key. --) + sig { returns(T::Hash[Integer, T.nilable(Temporalio::Api::TaskQueue::V1::TaskQueueStats)]) } + def stats_by_priority_key + end + + # Task queue stats breakdown by priority key. Only contains actively used priority keys. +# Only set if `report_task_queue_stats` is set to true in the request. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "by" is used to clarify the key. --) + sig { params(value: ::Google::Protobuf::Map).void } + def stats_by_priority_key=(value) + end + + # Task queue stats breakdown by priority key. Only contains actively used priority keys. +# Only set if `report_task_queue_stats` is set to true in the request. +# (-- api-linter: core::0140::prepositions=disabled +# aip.dev/not-precedent: "by" is used to clarify the key. --) + sig { void } + def clear_stats_by_priority_key + 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::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse::VersionTaskQueue) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse::VersionTaskQueue).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse::VersionTaskQueue) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse::VersionTaskQueue, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# (-- api-linter: core::0123::resource-annotation=disabled --) +# A subset of WorkerDeploymentInfo +class Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse::WorkerDeploymentSummary + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + name: T.nilable(String), + create_time: T.nilable(Google::Protobuf::Timestamp), + routing_config: T.nilable(Temporalio::Api::Deployment::V1::RoutingConfig), + latest_version_summary: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary), + current_version_summary: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary), + ramping_version_summary: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary) + ).void + end + def initialize( + name: "", + create_time: nil, + routing_config: nil, + latest_version_summary: nil, + current_version_summary: nil, + ramping_version_summary: nil + ) + end + + sig { returns(String) } + def name + end + + sig { params(value: String).void } + def name=(value) + end + + sig { void } + def clear_name + 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 { returns(T.nilable(Temporalio::Api::Deployment::V1::RoutingConfig)) } + def routing_config + end + + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::RoutingConfig)).void } + def routing_config=(value) + end + + sig { void } + def clear_routing_config + end + + # Summary of the version that was added most recently in the Worker Deployment. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary)) } + def latest_version_summary + end + + # Summary of the version that was added most recently in the Worker Deployment. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary)).void } + def latest_version_summary=(value) + end + + # Summary of the version that was added most recently in the Worker Deployment. + sig { void } + def clear_latest_version_summary + end + + # Summary of the current version of the Worker Deployment. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary)) } + def current_version_summary + end + + # Summary of the current version of the Worker Deployment. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary)).void } + def current_version_summary=(value) + end + + # Summary of the current version of the Worker Deployment. + sig { void } + def clear_current_version_summary + end + + # Summary of the ramping version of the Worker Deployment. + sig { returns(T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary)) } + def ramping_version_summary + end + + # Summary of the ramping version of the Worker Deployment. + sig { params(value: T.nilable(Temporalio::Api::Deployment::V1::WorkerDeploymentInfo::WorkerDeploymentVersionSummary)).void } + def ramping_version_summary=(value) + end + + # Summary of the ramping version of the Worker Deployment. + sig { void } + def clear_ramping_version_summary + 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::WorkflowService::V1::ListWorkerDeploymentsResponse::WorkerDeploymentSummary) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse::WorkerDeploymentSummary).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse::WorkerDeploymentSummary) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse::WorkerDeploymentSummary, 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::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + rate_limit: T.nilable(Temporalio::Api::TaskQueue::V1::RateLimit), + reason: T.nilable(String) + ).void + end + def initialize( + rate_limit: nil, + reason: "" + ) + end + + # Rate Limit to be updated + sig { returns(T.nilable(Temporalio::Api::TaskQueue::V1::RateLimit)) } + def rate_limit + end + + # Rate Limit to be updated + sig { params(value: T.nilable(Temporalio::Api::TaskQueue::V1::RateLimit)).void } + def rate_limit=(value) + end + + # Rate Limit to be updated + sig { void } + def clear_rate_limit + end + + # Reason for why the rate limit was set. + sig { returns(String) } + def reason + end + + # Reason for why the rate limit was set. + sig { params(value: String).void } + def reason=(value) + end + + # Reason for why the rate limit was set. + sig { void } + def clear_reason + 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::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest::RateLimitUpdate, 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::WorkflowService::V1::CountActivityExecutionsResponse::AggregationGroup + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_values: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + count: T.nilable(Integer) + ).void + end + def initialize( + group_values: [], + count: 0 + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def group_values + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def group_values=(value) + end + + sig { void } + def clear_group_values + end + + sig { returns(Integer) } + def count + end + + sig { params(value: Integer).void } + def count=(value) + end + + sig { void } + def clear_count + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse::AggregationGroup) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse::AggregationGroup).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse::AggregationGroup) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse::AggregationGroup, 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::WorkflowService::V1::CountNexusOperationExecutionsResponse::AggregationGroup + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + group_values: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + count: T.nilable(Integer) + ).void + end + def initialize( + group_values: [], + count: 0 + ) + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def group_values + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def group_values=(value) + end + + sig { void } + def clear_group_values + end + + sig { returns(Integer) } + def count + end + + sig { params(value: Integer).void } + def count=(value) + end + + sig { void } + def clear_count + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse::AggregationGroup) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse::AggregationGroup).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse::AggregationGroup) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse::AggregationGroup, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/api/workflowservice/v1/service.rbi b/temporalio/rbi/temporalio/api/workflowservice/v1/service.rbi new file mode 100644 index 00000000..ee66b53d --- /dev/null +++ b/temporalio/rbi/temporalio/api/workflowservice/v1/service.rbi @@ -0,0 +1,3 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/api/workflowservice/v1/service.proto +# typed: strict diff --git a/temporalio/rbi/temporalio/cancellation.rbi b/temporalio/rbi/temporalio/cancellation.rbi new file mode 100644 index 00000000..5b58a5c4 --- /dev/null +++ b/temporalio/rbi/temporalio/cancellation.rbi @@ -0,0 +1,43 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Cancellation + sig { params(parents: Temporalio::Cancellation).void } + def initialize(*parents); end + + sig { returns(T::Boolean) } + def canceled?; end + + sig { returns(T.nilable(String)) } + def canceled_reason; end + + sig { returns(T::Boolean) } + def pending_canceled?; end + + sig { returns(T.nilable(String)) } + def pending_canceled_reason; end + + sig { params(err: Exception).void } + def check!(err = T.unsafe(nil)); end + + sig { returns([Temporalio::Cancellation, Proc]) } + def to_ary; end + + sig { void } + def wait; end + + sig do + type_parameters(:T) + .params(blk: T.proc.returns(T.type_parameter(:T))) + .returns(T.type_parameter(:T)) + end + def shield(&blk); end + + sig { params(block: T.proc.void).returns(Object) } + def add_cancel_callback(&block); end + + sig { params(key: Object).void } + def remove_cancel_callback(key); end +end diff --git a/temporalio/rbi/temporalio/client.rbi b/temporalio/rbi/temporalio/client.rbi new file mode 100644 index 00000000..e008fad7 --- /dev/null +++ b/temporalio/rbi/temporalio/client.rbi @@ -0,0 +1,418 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client + sig do + params( + connection: Temporalio::Client::Connection, + namespace: String, + data_converter: Temporalio::Converters::DataConverter, + plugins: T::Array[Temporalio::Client::Plugin], + interceptors: T::Array[Temporalio::Client::Interceptor], + logger: ::Logger, + default_workflow_query_reject_condition: T.nilable(Integer) + ).void + end + def initialize( + connection:, + namespace:, + data_converter: T.unsafe(nil), + plugins: T.unsafe(nil), + interceptors: T.unsafe(nil), + logger: T.unsafe(nil), + default_workflow_query_reject_condition: T.unsafe(nil) + ) + end + sig { returns(Temporalio::Client::Options) } + attr_reader :options + + sig { returns(Temporalio::Client::Connection) } + def connection; end + + sig { returns(String) } + def namespace; end + + sig { returns(Temporalio::Converters::DataConverter) } + def data_converter; end + + sig { returns(Temporalio::Client::Connection::WorkflowService) } + def workflow_service; end + + sig { returns(Temporalio::Client::Connection::OperatorService) } + def operator_service; end + + sig do + params( + workflow: T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, + String), + args: T.nilable(Object), + id: String, + task_queue: String, + static_summary: T.nilable(String), + static_details: T.nilable(String), + execution_timeout: T.nilable(T.any(Integer, Float)), + run_timeout: T.nilable(T.any(Integer, Float)), + task_timeout: T.nilable(T.any(Integer, Float)), + id_reuse_policy: Integer, + id_conflict_policy: Integer, + retry_policy: T.nilable(Temporalio::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + start_delay: T.nilable(T.any(Integer, Float)), + request_eager_start: T::Boolean, + versioning_override: T.nilable(Temporalio::VersioningOverride), + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::WorkflowHandle) + end + def start_workflow( + workflow, + *args, + id:, + task_queue:, + static_summary: T.unsafe(nil), + static_details: T.unsafe(nil), + execution_timeout: T.unsafe(nil), + run_timeout: T.unsafe(nil), + task_timeout: T.unsafe(nil), + id_reuse_policy: T.unsafe(nil), + id_conflict_policy: T.unsafe(nil), + retry_policy: T.unsafe(nil), + cron_schedule: T.unsafe(nil), + memo: T.unsafe(nil), + search_attributes: T.unsafe(nil), + start_delay: T.unsafe(nil), + request_eager_start: T.unsafe(nil), + versioning_override: T.unsafe(nil), + priority: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil), + rpc_options: T.unsafe(nil) + ) + end + sig do + params( + workflow: T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, + String), + args: T.nilable(Object), + id: String, + task_queue: String, + static_summary: T.nilable(String), + static_details: T.nilable(String), + execution_timeout: T.nilable(T.any(Integer, Float)), + run_timeout: T.nilable(T.any(Integer, Float)), + task_timeout: T.nilable(T.any(Integer, Float)), + id_reuse_policy: Integer, + id_conflict_policy: Integer, + retry_policy: T.nilable(Temporalio::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + start_delay: T.nilable(T.any(Integer, Float)), + request_eager_start: T::Boolean, + versioning_override: T.nilable(Temporalio::VersioningOverride), + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T.nilable(Object)) + end + def execute_workflow( + workflow, + *args, + id:, + task_queue:, + static_summary: T.unsafe(nil), + static_details: T.unsafe(nil), + execution_timeout: T.unsafe(nil), + run_timeout: T.unsafe(nil), + task_timeout: T.unsafe(nil), + id_reuse_policy: T.unsafe(nil), + id_conflict_policy: T.unsafe(nil), + retry_policy: T.unsafe(nil), + cron_schedule: T.unsafe(nil), + memo: T.unsafe(nil), + search_attributes: T.unsafe(nil), + start_delay: T.unsafe(nil), + request_eager_start: T.unsafe(nil), + versioning_override: T.unsafe(nil), + priority: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil), + rpc_options: T.unsafe(nil) + ) + end + sig do + params( + workflow_id: String, + run_id: T.nilable(String), + first_execution_run_id: T.nilable(String), + result_hint: T.nilable(Object) + ).returns(Temporalio::Client::WorkflowHandle) + end + def workflow_handle(workflow_id, run_id: T.unsafe(nil), first_execution_run_id: T.unsafe(nil), + result_hint: T.unsafe(nil)) + end + + sig do + params( + update: T.any(Temporalio::Workflow::Definition::Update, Symbol, String), + args: T.nilable(Object), + start_workflow_operation: Temporalio::Client::WithStartWorkflowOperation, + wait_for_stage: Integer, + id: String, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::WorkflowUpdateHandle) + end + def start_update_with_start_workflow( + update, + *args, + start_workflow_operation:, + wait_for_stage:, + id: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil), + rpc_options: T.unsafe(nil) + ) + end + sig do + params( + update: T.any(Temporalio::Workflow::Definition::Update, Symbol, String), + args: T.nilable(Object), + start_workflow_operation: Temporalio::Client::WithStartWorkflowOperation, + id: String, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T.nilable(Object)) + end + def execute_update_with_start_workflow( + update, + *args, + start_workflow_operation:, + id: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil), + rpc_options: T.unsafe(nil) + ) + end + sig do + params( + signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String), + args: T.nilable(Object), + start_workflow_operation: Temporalio::Client::WithStartWorkflowOperation, + arg_hints: T.nilable(T::Array[Object]), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::WorkflowHandle) + end + def signal_with_start_workflow( + signal, + *args, + start_workflow_operation:, + arg_hints: T.unsafe(nil), + rpc_options: T.unsafe(nil) + ) + end + sig do + params( + query: T.nilable(String), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T::Enumerator[Temporalio::Client::WorkflowExecution]) + end + def list_workflows(query = T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + query: T.nilable(String), + page_size: T.nilable(Integer), + next_page_token: T.nilable(String), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::ListWorkflowPage) + end + def list_workflow_page(query = T.unsafe(nil), page_size: T.unsafe(nil), next_page_token: T.unsafe(nil), + rpc_options: T.unsafe(nil)) + end + + sig do + params( + query: T.nilable(String), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::WorkflowExecutionCount) + end + def count_workflows(query = T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + id: String, + schedule: Temporalio::Client::Schedule, + trigger_immediately: T::Boolean, + backfills: T::Array[Temporalio::Client::Schedule::Backfill], + memo: T.nilable(T::Hash[String, T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::ScheduleHandle) + end + def create_schedule( + id, + schedule, + trigger_immediately: T.unsafe(nil), + backfills: T.unsafe(nil), + memo: T.unsafe(nil), + search_attributes: T.unsafe(nil), + rpc_options: T.unsafe(nil) + ) + end + sig { params(id: String).returns(Temporalio::Client::ScheduleHandle) } + def schedule_handle(id); end + + sig do + params( + query: T.nilable(String), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T::Enumerator[Temporalio::Client::Schedule::List::Description]) + end + def list_schedules(query = T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + task_token_or_id_reference: T.any(String, Temporalio::Client::ActivityIDReference) + ).returns(Temporalio::Client::AsyncActivityHandle) + end + def async_activity_handle(task_token_or_id_reference); end + + class << self + sig do + params( + target_host: String, + namespace: String, + api_key: T.nilable(String), + tls: T.nilable(T.any(T::Boolean, Temporalio::Client::Connection::TLSOptions)), + data_converter: Temporalio::Converters::DataConverter, + plugins: T::Array[Temporalio::Client::Plugin], + interceptors: T::Array[Temporalio::Client::Interceptor], + logger: ::Logger, + default_workflow_query_reject_condition: T.nilable(Integer), + rpc_metadata: T::Hash[String, String], + rpc_retry: Temporalio::Client::Connection::RPCRetryOptions, + identity: String, + keep_alive: Temporalio::Client::Connection::KeepAliveOptions, + http_connect_proxy: T.nilable(Temporalio::Client::Connection::HTTPConnectProxyOptions), + runtime: Temporalio::Runtime, + lazy_connect: T::Boolean, + dns_load_balancing: T.nilable(Temporalio::Client::Connection::DnsLoadBalancingOptions) + ).returns(Temporalio::Client) + end + def connect( + target_host, + namespace, + api_key: T.unsafe(nil), + tls: T.unsafe(nil), + data_converter: T.unsafe(nil), + plugins: T.unsafe(nil), + interceptors: T.unsafe(nil), + logger: T.unsafe(nil), + default_workflow_query_reject_condition: T.unsafe(nil), + rpc_metadata: T.unsafe(nil), + rpc_retry: T.unsafe(nil), + identity: T.unsafe(nil), + keep_alive: T.unsafe(nil), + http_connect_proxy: T.unsafe(nil), + runtime: T.unsafe(nil), + lazy_connect: T.unsafe(nil), + dns_load_balancing: T.unsafe(nil) + ) + end + end +end + +class Temporalio::Client::Options < Data + sig { returns(Temporalio::Client::Connection) } + def connection; end + + sig { returns(String) } + def namespace; end + + sig { returns(Temporalio::Converters::DataConverter) } + def data_converter; end + + sig { returns(T::Array[Temporalio::Client::Plugin]) } + def plugins; end + + sig { returns(T::Array[Temporalio::Client::Interceptor]) } + def interceptors; end + + sig { returns(::Logger) } + def logger; end + + sig { returns(T.nilable(Integer)) } + def default_workflow_query_reject_condition; end + + sig { returns(T::Hash[Symbol, Object]) } + def to_h; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Client::Options) } + def with(**kwargs); end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Options) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Options) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::ListWorkflowPage < Data + sig { returns(T::Array[Temporalio::Client::WorkflowExecution]) } + def executions; end + + sig { returns(T.nilable(String)) } + def next_page_token; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::ListWorkflowPage) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::ListWorkflowPage) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::RPCOptions + sig do + params( + metadata: T.nilable(T::Hash[String, String]), + timeout: T.nilable(Float), + cancellation: T.nilable(Temporalio::Cancellation), + override_retry: T.nilable(T::Boolean) + ).void + end + def initialize(metadata: T.unsafe(nil), timeout: T.unsafe(nil), cancellation: T.unsafe(nil), + override_retry: T.unsafe(nil)) + end + + sig { returns(T.nilable(T::Hash[String, String])) } + attr_accessor :metadata + + sig { returns(T.nilable(Float)) } + attr_accessor :timeout + + sig { returns(T.nilable(Temporalio::Cancellation)) } + attr_accessor :cancellation + + sig { returns(T.nilable(T::Boolean)) } + attr_accessor :override_retry +end diff --git a/temporalio/rbi/temporalio/client/activity_id_reference.rbi b/temporalio/rbi/temporalio/client/activity_id_reference.rbi new file mode 100644 index 00000000..6cbe2edf --- /dev/null +++ b/temporalio/rbi/temporalio/client/activity_id_reference.rbi @@ -0,0 +1,18 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::ActivityIDReference + sig { params(workflow_id: String, run_id: T.nilable(String), activity_id: String).void } + def initialize(workflow_id:, run_id:, activity_id:); end + + sig { returns(String) } + attr_reader :workflow_id + + sig { returns(T.nilable(String)) } + attr_reader :run_id + + sig { returns(String) } + attr_reader :activity_id +end diff --git a/temporalio/rbi/temporalio/client/async_activity_handle.rbi b/temporalio/rbi/temporalio/client/async_activity_handle.rbi new file mode 100644 index 00000000..148e0772 --- /dev/null +++ b/temporalio/rbi/temporalio/client/async_activity_handle.rbi @@ -0,0 +1,52 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::AsyncActivityHandle + sig { params(client: Temporalio::Client, task_token: T.nilable(String), id_reference: T.nilable(Temporalio::Client::ActivityIDReference)).void } + def initialize(client:, task_token:, id_reference:); end + + sig { returns(T.nilable(String)) } + attr_reader :task_token + + sig { returns(T.nilable(Temporalio::Client::ActivityIDReference)) } + attr_reader :id_reference + + sig do + params( + details: T.nilable(Object), + detail_hints: T.nilable(T::Array[Object]), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).void + end + def heartbeat(*details, detail_hints: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + result: T.nilable(Object), + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).void + end + def complete(result = T.unsafe(nil), result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + error: Exception, + last_heartbeat_details: T::Array[T.nilable(Object)], + last_heartbeat_detail_hints: T.nilable(T::Array[Object]), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).void + end + def fail(error, last_heartbeat_details: T.unsafe(nil), last_heartbeat_detail_hints: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + details: T.nilable(Object), + detail_hints: T.nilable(T::Array[Object]), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).void + end + def report_cancellation(*details, detail_hints: T.unsafe(nil), rpc_options: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/client/connection.rbi b/temporalio/rbi/temporalio/client/connection.rbi new file mode 100644 index 00000000..112558d7 --- /dev/null +++ b/temporalio/rbi/temporalio/client/connection.rbi @@ -0,0 +1,270 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::Connection + sig do + params( + target_host: String, + api_key: T.nilable(String), + tls: T.nilable(T.any(T::Boolean, Temporalio::Client::Connection::TLSOptions)), + rpc_metadata: T::Hash[String, String], + rpc_retry: Temporalio::Client::Connection::RPCRetryOptions, + identity: String, + keep_alive: Temporalio::Client::Connection::KeepAliveOptions, + http_connect_proxy: T.nilable(Temporalio::Client::Connection::HTTPConnectProxyOptions), + runtime: Temporalio::Runtime, + lazy_connect: T::Boolean, + dns_load_balancing: T.nilable(Temporalio::Client::Connection::DnsLoadBalancingOptions), + around_connect: T.nilable(T.proc.params(arg0: Temporalio::Client::Connection::Options, arg1: T.proc.params(arg0: Temporalio::Client::Connection::Options).void).void) + ).void + end + def initialize( + target_host:, + api_key: T.unsafe(nil), + tls: T.unsafe(nil), + rpc_metadata: T.unsafe(nil), + rpc_retry: T.unsafe(nil), + identity: T.unsafe(nil), + keep_alive: T.unsafe(nil), + http_connect_proxy: T.unsafe(nil), + runtime: T.unsafe(nil), + lazy_connect: T.unsafe(nil), + dns_load_balancing: T.unsafe(nil), + around_connect: T.unsafe(nil) + ); end + + sig { returns(Temporalio::Client::Connection::Options) } + attr_reader :options + + sig { returns(Temporalio::Client::Connection::WorkflowService) } + attr_reader :workflow_service + + sig { returns(Temporalio::Client::Connection::OperatorService) } + attr_reader :operator_service + + sig { returns(Temporalio::Client::Connection::CloudService) } + attr_reader :cloud_service + + sig { returns(String) } + def target_host; end + + sig { returns(String) } + def identity; end + + sig { returns(T::Boolean) } + def connected?; end + + sig { returns(T.nilable(String)) } + def api_key; end + + sig { params(new_key: T.nilable(String)).void } + def api_key=(new_key); end + + sig { returns(T::Hash[String, String]) } + def rpc_metadata; end + + sig { params(rpc_metadata: T::Hash[String, String]).void } + def rpc_metadata=(rpc_metadata); end +end + +class Temporalio::Client::Connection::Options < ::Data + sig { returns(String) } + def target_host; end + + sig { returns(T.nilable(String)) } + def api_key; end + + sig { returns(T.nilable(T.any(T::Boolean, Temporalio::Client::Connection::TLSOptions))) } + def tls; end + + sig { returns(T::Hash[String, String]) } + def rpc_metadata; end + + sig { returns(Temporalio::Client::Connection::RPCRetryOptions) } + def rpc_retry; end + + sig { returns(String) } + def identity; end + + sig { returns(Temporalio::Client::Connection::KeepAliveOptions) } + def keep_alive; end + + sig { returns(T.nilable(Temporalio::Client::Connection::HTTPConnectProxyOptions)) } + def http_connect_proxy; end + + sig { returns(Temporalio::Runtime) } + def runtime; end + + sig { returns(T::Boolean) } + def lazy_connect; end + + sig { returns(T.nilable(Temporalio::Client::Connection::DnsLoadBalancingOptions)) } + def dns_load_balancing; end + + sig { returns(T::Hash[Symbol, Object]) } + def to_h; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Client::Connection::Options) } + def with(**kwargs); end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::Options) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::Options) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Connection::TLSOptions < ::Data + sig do + params( + client_cert: T.nilable(String), + client_private_key: T.nilable(String), + server_root_ca_cert: T.nilable(String), + domain: T.nilable(String) + ).void + end + def initialize(client_cert: T.unsafe(nil), client_private_key: T.unsafe(nil), server_root_ca_cert: T.unsafe(nil), domain: T.unsafe(nil)); end + + sig { returns(T.nilable(String)) } + def client_cert; end + + sig { returns(T.nilable(String)) } + def client_private_key; end + + sig { returns(T.nilable(String)) } + def server_root_ca_cert; end + + sig { returns(T.nilable(String)) } + def domain; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::TLSOptions) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::TLSOptions) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Connection::RPCRetryOptions < ::Data + sig do + params( + initial_interval: Float, + randomization_factor: Float, + multiplier: Float, + max_interval: Float, + max_elapsed_time: Float, + max_retries: Integer + ).void + end + def initialize( + initial_interval: T.unsafe(nil), + randomization_factor: T.unsafe(nil), + multiplier: T.unsafe(nil), + max_interval: T.unsafe(nil), + max_elapsed_time: T.unsafe(nil), + max_retries: T.unsafe(nil) + ); end + + sig { returns(Float) } + def initial_interval; end + + sig { returns(Float) } + def randomization_factor; end + + sig { returns(Float) } + def multiplier; end + + sig { returns(Float) } + def max_interval; end + + sig { returns(Float) } + def max_elapsed_time; end + + sig { returns(Integer) } + def max_retries; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::RPCRetryOptions) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::RPCRetryOptions) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Connection::KeepAliveOptions < ::Data + sig { params(interval: Float, timeout: Float).void } + def initialize(interval: T.unsafe(nil), timeout: T.unsafe(nil)); end + + sig { returns(Float) } + def interval; end + + sig { returns(Float) } + def timeout; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::KeepAliveOptions) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::KeepAliveOptions) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Connection::HTTPConnectProxyOptions < ::Data + sig { returns(String) } + def target_host; end + + sig { returns(T.nilable(String)) } + def basic_auth_user; end + + sig { returns(T.nilable(String)) } + def basic_auth_pass; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::HTTPConnectProxyOptions) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Connection::HTTPConnectProxyOptions) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Connection::DnsLoadBalancingOptions < ::Data + sig { params(resolution_interval: Float).void } + def initialize(resolution_interval: T.unsafe(nil)); end + + sig { returns(Float) } + def resolution_interval; end + + class << self + sig { params(resolution_interval: Float).returns(Temporalio::Client::Connection::DnsLoadBalancingOptions) } + def new(resolution_interval: T.unsafe(nil)); end + + sig { params(resolution_interval: Float).returns(Temporalio::Client::Connection::DnsLoadBalancingOptions) } + def [](resolution_interval: T.unsafe(nil)); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end diff --git a/temporalio/rbi/temporalio/client/connection/cloud_service.rbi b/temporalio/rbi/temporalio/client/connection/cloud_service.rbi new file mode 100644 index 00000000..97eb6f6b --- /dev/null +++ b/temporalio/rbi/temporalio/client/connection/cloud_service.rbi @@ -0,0 +1,215 @@ +# typed: false +# frozen_string_literal: true + +# Generated code. DO NOT EDIT! + +class Temporalio::Client::Connection::CloudService < ::Temporalio::Client::Connection::Service + extend T::Sig + + sig { params(connection: Temporalio::Client::Connection).void } + def initialize(connection); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetCurrentIdentityResponse) } + def get_current_identity(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetUsersRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetUsersResponse) } + def get_users(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetUserRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserResponse) } + def get_user(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateUserRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateUserResponse) } + def create_user(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateUserRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateUserResponse) } + def update_user(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteUserRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteUserResponse) } + def delete_user(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::SetUserNamespaceAccessRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::SetUserNamespaceAccessResponse) } + def set_user_namespace_access(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetAsyncOperationRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetAsyncOperationResponse) } + def get_async_operation(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceResponse) } + def create_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetNamespacesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespacesResponse) } + def get_namespaces(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceResponse) } + def get_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceResponse) } + def update_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::RenameCustomSearchAttributeRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::RenameCustomSearchAttributeResponse) } + def rename_custom_search_attribute(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceResponse) } + def delete_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::FailoverNamespaceRegionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::FailoverNamespaceRegionResponse) } + def failover_namespace_region(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::AddNamespaceRegionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::AddNamespaceRegionResponse) } + def add_namespace_region(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceRegionResponse) } + def delete_namespace_region(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetRegionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetRegionsResponse) } + def get_regions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetRegionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetRegionResponse) } + def get_region(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetApiKeysRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetApiKeysResponse) } + def get_api_keys(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetApiKeyRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetApiKeyResponse) } + def get_api_key(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateApiKeyRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateApiKeyResponse) } + def create_api_key(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateApiKeyRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateApiKeyResponse) } + def update_api_key(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteApiKeyRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteApiKeyResponse) } + def delete_api_key(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointsResponse) } + def get_nexus_endpoints(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetNexusEndpointResponse) } + def get_nexus_endpoint(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateNexusEndpointRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNexusEndpointResponse) } + def create_nexus_endpoint(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateNexusEndpointRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNexusEndpointResponse) } + def update_nexus_endpoint(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteNexusEndpointRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNexusEndpointResponse) } + def delete_nexus_endpoint(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupsResponse) } + def get_user_groups(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupResponse) } + def get_user_group(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateUserGroupRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateUserGroupResponse) } + def create_user_group(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateUserGroupRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateUserGroupResponse) } + def update_user_group(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteUserGroupRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteUserGroupResponse) } + def delete_user_group(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::SetUserGroupNamespaceAccessRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::SetUserGroupNamespaceAccessResponse) } + def set_user_group_namespace_access(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::AddUserGroupMemberResponse) } + def add_user_group_member(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::RemoveUserGroupMemberResponse) } + def remove_user_group_member(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetUserGroupMembersResponse) } + def get_user_group_members(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateServiceAccountResponse) } + def create_service_account(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountResponse) } + def get_service_account(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetServiceAccountsResponse) } + def get_service_accounts(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateServiceAccountRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateServiceAccountResponse) } + def update_service_account(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::SetServiceAccountNamespaceAccessResponse) } + def set_service_account_namespace_access(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteServiceAccountRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteServiceAccountResponse) } + def delete_service_account(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetUsageRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetUsageResponse) } + def get_usage(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetAccountRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountResponse) } + def get_account(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateAccountResponse) } + def update_account(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceExportSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateNamespaceExportSinkResponse) } + def create_namespace_export_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinkResponse) } + def get_namespace_export_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinksRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceExportSinksResponse) } + def get_namespace_export_sinks(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceExportSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceExportSinkResponse) } + def update_namespace_export_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceExportSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteNamespaceExportSinkResponse) } + def delete_namespace_export_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::ValidateNamespaceExportSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::ValidateNamespaceExportSinkResponse) } + def validate_namespace_export_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceTagsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateNamespaceTagsResponse) } + def update_namespace_tags(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateConnectivityRuleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateConnectivityRuleResponse) } + def create_connectivity_rule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRuleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRuleResponse) } + def get_connectivity_rule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRulesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetConnectivityRulesResponse) } + def get_connectivity_rules(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteConnectivityRuleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteConnectivityRuleResponse) } + def delete_connectivity_rule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetAuditLogsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetAuditLogsResponse) } + def get_audit_logs(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::ValidateAccountAuditLogSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::ValidateAccountAuditLogSinkResponse) } + def validate_account_audit_log_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateAccountAuditLogSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateAccountAuditLogSinkResponse) } + def create_account_audit_log_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinkResponse) } + def get_account_audit_log_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinksRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetAccountAuditLogSinksResponse) } + def get_account_audit_log_sinks(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::UpdateAccountAuditLogSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::UpdateAccountAuditLogSinkResponse) } + def update_account_audit_log_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::DeleteAccountAuditLogSinkRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::DeleteAccountAuditLogSinkResponse) } + def delete_account_audit_log_sink(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetNamespaceCapacityInfoRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetNamespaceCapacityInfoResponse) } + def get_namespace_capacity_info(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::CreateBillingReportRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::CreateBillingReportResponse) } + def create_billing_report(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::Cloud::CloudService::V1::GetBillingReportRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::Cloud::CloudService::V1::GetBillingReportResponse) } + def get_billing_report(request, rpc_options: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/client/connection/operator_service.rbi b/temporalio/rbi/temporalio/client/connection/operator_service.rbi new file mode 100644 index 00000000..69240f0d --- /dev/null +++ b/temporalio/rbi/temporalio/client/connection/operator_service.rbi @@ -0,0 +1,47 @@ +# typed: false +# frozen_string_literal: true + +# Generated code. DO NOT EDIT! + +class Temporalio::Client::Connection::OperatorService < ::Temporalio::Client::Connection::Service + extend T::Sig + + sig { params(connection: Temporalio::Client::Connection).void } + def initialize(connection); end + + sig { params(request: Temporalio::Api::OperatorService::V1::AddSearchAttributesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::AddSearchAttributesResponse) } + def add_search_attributes(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::RemoveSearchAttributesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::RemoveSearchAttributesResponse) } + def remove_search_attributes(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::ListSearchAttributesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::ListSearchAttributesResponse) } + def list_search_attributes(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::DeleteNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::DeleteNamespaceResponse) } + def delete_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::AddOrUpdateRemoteClusterRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::AddOrUpdateRemoteClusterResponse) } + def add_or_update_remote_cluster(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::RemoveRemoteClusterRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::RemoveRemoteClusterResponse) } + def remove_remote_cluster(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::ListClustersRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::ListClustersResponse) } + def list_clusters(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::GetNexusEndpointRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::GetNexusEndpointResponse) } + def get_nexus_endpoint(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::CreateNexusEndpointRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::CreateNexusEndpointResponse) } + def create_nexus_endpoint(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::UpdateNexusEndpointRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::UpdateNexusEndpointResponse) } + def update_nexus_endpoint(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::DeleteNexusEndpointRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::DeleteNexusEndpointResponse) } + def delete_nexus_endpoint(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::OperatorService::V1::ListNexusEndpointsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::OperatorService::V1::ListNexusEndpointsResponse) } + def list_nexus_endpoints(request, rpc_options: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/client/connection/service.rbi b/temporalio/rbi/temporalio/client/connection/service.rbi new file mode 100644 index 00000000..920c02e0 --- /dev/null +++ b/temporalio/rbi/temporalio/client/connection/service.rbi @@ -0,0 +1,22 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::Connection::Service + sig { params(connection: Temporalio::Client::Connection, service: Integer).void } + def initialize(connection, service); end + + protected + + sig do + params( + rpc: String, + request_class: T.class_of(Object), + response_class: T.class_of(Object), + request: Object, + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Object) + end + def invoke_rpc(rpc:, request_class:, response_class:, request:, rpc_options:); end +end diff --git a/temporalio/rbi/temporalio/client/connection/test_service.rbi b/temporalio/rbi/temporalio/client/connection/test_service.rbi new file mode 100644 index 00000000..c235648b --- /dev/null +++ b/temporalio/rbi/temporalio/client/connection/test_service.rbi @@ -0,0 +1,29 @@ +# typed: false +# frozen_string_literal: true + +# Generated code. DO NOT EDIT! + +class Temporalio::Client::Connection::TestService < ::Temporalio::Client::Connection::Service + extend T::Sig + + sig { params(connection: Temporalio::Client::Connection).void } + def initialize(connection); end + + sig { params(request: Temporalio::Api::TestService::V1::LockTimeSkippingRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::TestService::V1::LockTimeSkippingResponse) } + def lock_time_skipping(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::TestService::V1::UnlockTimeSkippingRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::TestService::V1::UnlockTimeSkippingResponse) } + def unlock_time_skipping(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::TestService::V1::SleepRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::TestService::V1::SleepResponse) } + def sleep(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::TestService::V1::SleepUntilRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::TestService::V1::SleepResponse) } + def sleep_until(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::TestService::V1::SleepRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::TestService::V1::SleepResponse) } + def unlock_time_skipping_with_sleep(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Google::Protobuf::Empty, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::TestService::V1::GetCurrentTimeResponse) } + def get_current_time(request, rpc_options: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/client/connection/workflow_service.rbi b/temporalio/rbi/temporalio/client/connection/workflow_service.rbi new file mode 100644 index 00000000..fd978bde --- /dev/null +++ b/temporalio/rbi/temporalio/client/connection/workflow_service.rbi @@ -0,0 +1,362 @@ +# typed: false +# frozen_string_literal: true + +# Generated code. DO NOT EDIT! + +class Temporalio::Client::Connection::WorkflowService < ::Temporalio::Client::Connection::Service + extend T::Sig + + sig { params(connection: Temporalio::Client::Connection).void } + def initialize(connection); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RegisterNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RegisterNamespaceResponse) } + def register_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeNamespaceResponse) } + def describe_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListNamespacesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListNamespacesResponse) } + def list_namespaces(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateNamespaceResponse) } + def update_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DeprecateNamespaceRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeprecateNamespaceResponse) } + def deprecate_namespace(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::StartWorkflowExecutionResponse) } + def start_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ExecuteMultiOperationResponse) } + def execute_multi_operation(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryResponse) } + def get_workflow_execution_history(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryReverseRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetWorkflowExecutionHistoryReverseResponse) } + def get_workflow_execution_history_reverse(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PollWorkflowTaskQueueResponse) } + def poll_workflow_task_queue(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskCompletedResponse) } + def respond_workflow_task_completed(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskFailedRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondWorkflowTaskFailedResponse) } + def respond_workflow_task_failed(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PollActivityTaskQueueResponse) } + def poll_activity_task_queue(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatResponse) } + def record_activity_task_heartbeat(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RecordActivityTaskHeartbeatByIdResponse) } + def record_activity_task_heartbeat_by_id(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedResponse) } + def respond_activity_task_completed(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdResponse) } + def respond_activity_task_completed_by_id(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedResponse) } + def respond_activity_task_failed(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedByIdRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskFailedByIdResponse) } + def respond_activity_task_failed_by_id(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledResponse) } + def respond_activity_task_canceled(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledByIdRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondActivityTaskCanceledByIdResponse) } + def respond_activity_task_canceled_by_id(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RequestCancelWorkflowExecutionResponse) } + def request_cancel_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::SignalWorkflowExecutionResponse) } + def signal_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::SignalWithStartWorkflowExecutionResponse) } + def signal_with_start_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ResetWorkflowExecutionResponse) } + def reset_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::TerminateWorkflowExecutionResponse) } + def terminate_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DeleteWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkflowExecutionResponse) } + def delete_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListOpenWorkflowExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListOpenWorkflowExecutionsResponse) } + def list_open_workflow_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListClosedWorkflowExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListClosedWorkflowExecutionsResponse) } + def list_closed_workflow_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListWorkflowExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListWorkflowExecutionsResponse) } + def list_workflow_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListArchivedWorkflowExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListArchivedWorkflowExecutionsResponse) } + def list_archived_workflow_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ScanWorkflowExecutionsResponse) } + def scan_workflow_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::CountWorkflowExecutionsResponse) } + def count_workflow_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetSearchAttributesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetSearchAttributesResponse) } + def get_search_attributes(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondQueryTaskCompletedRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondQueryTaskCompletedResponse) } + def respond_query_task_completed(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ResetStickyTaskQueueRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ResetStickyTaskQueueResponse) } + def reset_sticky_task_queue(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ShutdownWorkerRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ShutdownWorkerResponse) } + def shutdown_worker(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::QueryWorkflowRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::QueryWorkflowResponse) } + def query_workflow(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse) } + def describe_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeTaskQueueRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeTaskQueueResponse) } + def describe_task_queue(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetClusterInfoRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetClusterInfoResponse) } + def get_cluster_info(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetSystemInfoRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetSystemInfoResponse) } + def get_system_info(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListTaskQueuePartitionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListTaskQueuePartitionsResponse) } + def list_task_queue_partitions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::CreateScheduleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::CreateScheduleResponse) } + def create_schedule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeScheduleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeScheduleResponse) } + def describe_schedule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateScheduleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateScheduleResponse) } + def update_schedule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PatchScheduleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PatchScheduleResponse) } + def patch_schedule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListScheduleMatchingTimesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListScheduleMatchingTimesResponse) } + def list_schedule_matching_times(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DeleteScheduleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeleteScheduleResponse) } + def delete_schedule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListSchedulesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListSchedulesResponse) } + def list_schedules(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::CountSchedulesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::CountSchedulesResponse) } + def count_schedules(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerBuildIdCompatibilityResponse) } + def update_worker_build_id_compatibility(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetWorkerBuildIdCompatibilityResponse) } + def get_worker_build_id_compatibility(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerVersioningRulesResponse) } + def update_worker_versioning_rules(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetWorkerVersioningRulesResponse) } + def get_worker_versioning_rules(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetWorkerTaskReachabilityResponse) } + def get_worker_task_reachability(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeDeploymentRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeDeploymentResponse) } + def describe_deployment(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentVersionResponse) } + def describe_worker_deployment_version(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListDeploymentsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListDeploymentsResponse) } + def list_deployments(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetDeploymentReachabilityResponse) } + def get_deployment_reachability(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::GetCurrentDeploymentResponse) } + def get_current_deployment(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::SetCurrentDeploymentResponse) } + def set_current_deployment(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentCurrentVersionResponse) } + def set_worker_deployment_current_version(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerDeploymentResponse) } + def describe_worker_deployment(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentResponse) } + def delete_worker_deployment(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkerDeploymentVersionResponse) } + def delete_worker_deployment_version(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentRampingVersionResponse) } + def set_worker_deployment_ramping_version(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListWorkerDeploymentsResponse) } + def list_worker_deployments(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentResponse) } + def create_worker_deployment(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::CreateWorkerDeploymentVersionResponse) } + def create_worker_deployment_version(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionComputeConfigResponse) } + def update_worker_deployment_version_compute_config(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ValidateWorkerDeploymentVersionComputeConfigResponse) } + def validate_worker_deployment_version_compute_config(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerDeploymentVersionMetadataResponse) } + def update_worker_deployment_version_metadata(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::SetWorkerDeploymentManagerResponse) } + def set_worker_deployment_manager(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionResponse) } + def update_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionUpdateRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PollWorkflowExecutionUpdateResponse) } + def poll_workflow_execution_update(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::StartBatchOperationRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::StartBatchOperationResponse) } + def start_batch_operation(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::StopBatchOperationRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::StopBatchOperationResponse) } + def stop_batch_operation(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeBatchOperationRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeBatchOperationResponse) } + def describe_batch_operation(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListBatchOperationsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListBatchOperationsResponse) } + def list_batch_operations(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueResponse) } + def poll_nexus_task_queue(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondNexusTaskCompletedRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondNexusTaskCompletedResponse) } + def respond_nexus_task_completed(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RespondNexusTaskFailedRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RespondNexusTaskFailedResponse) } + def respond_nexus_task_failed(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateActivityOptionsResponse) } + def update_activity_options(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkflowExecutionOptionsResponse) } + def update_workflow_execution_options(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PauseActivityRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PauseActivityResponse) } + def pause_activity(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UnpauseActivityRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UnpauseActivityResponse) } + def unpause_activity(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ResetActivityRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ResetActivityResponse) } + def reset_activity(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::CreateWorkflowRuleResponse) } + def create_workflow_rule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkflowRuleResponse) } + def describe_workflow_rule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeleteWorkflowRuleResponse) } + def delete_workflow_rule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListWorkflowRulesRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListWorkflowRulesResponse) } + def list_workflow_rules(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::TriggerWorkflowRuleResponse) } + def trigger_workflow_rule(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RecordWorkerHeartbeatResponse) } + def record_worker_heartbeat(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListWorkersRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListWorkersResponse) } + def list_workers(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateTaskQueueConfigResponse) } + def update_task_queue_config(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::FetchWorkerConfigRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::FetchWorkerConfigResponse) } + def fetch_worker_config(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UpdateWorkerConfigRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UpdateWorkerConfigResponse) } + def update_worker_config(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeWorkerRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeWorkerResponse) } + def describe_worker(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PauseWorkflowExecutionResponse) } + def pause_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::UnpauseWorkflowExecutionResponse) } + def unpause_workflow_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::StartActivityExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::StartActivityExecutionResponse) } + def start_activity_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::StartNexusOperationExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::StartNexusOperationExecutionResponse) } + def start_nexus_operation_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeActivityExecutionResponse) } + def describe_activity_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DescribeNexusOperationExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DescribeNexusOperationExecutionResponse) } + def describe_nexus_operation_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PollActivityExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PollActivityExecutionResponse) } + def poll_activity_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::PollNexusOperationExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::PollNexusOperationExecutionResponse) } + def poll_nexus_operation_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListActivityExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListActivityExecutionsResponse) } + def list_activity_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::ListNexusOperationExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::ListNexusOperationExecutionsResponse) } + def list_nexus_operation_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::CountActivityExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::CountActivityExecutionsResponse) } + def count_activity_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::CountNexusOperationExecutionsResponse) } + def count_nexus_operation_executions(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RequestCancelActivityExecutionResponse) } + def request_cancel_activity_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::RequestCancelNexusOperationExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::RequestCancelNexusOperationExecutionResponse) } + def request_cancel_nexus_operation_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::TerminateActivityExecutionResponse) } + def terminate_activity_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeleteActivityExecutionResponse) } + def delete_activity_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::TerminateNexusOperationExecutionResponse) } + def terminate_nexus_operation_execution(request, rpc_options: T.unsafe(nil)); end + + sig { params(request: Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionRequest, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Api::WorkflowService::V1::DeleteNexusOperationExecutionResponse) } + def delete_nexus_operation_execution(request, rpc_options: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/client/interceptor.rbi b/temporalio/rbi/temporalio/client/interceptor.rbi new file mode 100644 index 00000000..7ecc9ed2 --- /dev/null +++ b/temporalio/rbi/temporalio/client/interceptor.rbi @@ -0,0 +1,844 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Client::Interceptor + sig { params(next_interceptor: Temporalio::Client::Interceptor::Outbound).returns(Temporalio::Client::Interceptor::Outbound) } + def intercept_client(next_interceptor); end +end + +class Temporalio::Client::Interceptor::StartWorkflowInput < ::Data + sig { returns(String) } + def workflow; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(String) } + def workflow_id; end + + sig { returns(String) } + def task_queue; end + + sig { returns(T.nilable(String)) } + def static_summary; end + + sig { returns(T.nilable(String)) } + def static_details; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def execution_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def run_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def task_timeout; end + + sig { returns(Integer) } + def id_reuse_policy; end + + sig { returns(Integer) } + def id_conflict_policy; end + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + def retry_policy; end + + sig { returns(T.nilable(String)) } + def cron_schedule; end + + sig { returns(T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)])) } + def memo; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def start_delay; end + + sig { returns(T::Boolean) } + def request_eager_start; end + + sig { returns(T.nilable(Temporalio::VersioningOverride)) } + def versioning_override; end + + sig { returns(Temporalio::Priority) } + def priority; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::StartWorkflowInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::StartWorkflowInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::StartUpdateWithStartWorkflowInput < ::Data + sig { returns(String) } + def update_id; end + + sig { returns(String) } + def update; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(Integer) } + def wait_for_stage; end + + sig { returns(Temporalio::Client::WithStartWorkflowOperation) } + def start_workflow_operation; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::StartUpdateWithStartWorkflowInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::StartUpdateWithStartWorkflowInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::SignalWithStartWorkflowInput < ::Data + sig { returns(String) } + def signal; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(Temporalio::Client::WithStartWorkflowOperation) } + def start_workflow_operation; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::SignalWithStartWorkflowInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::SignalWithStartWorkflowInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::ListWorkflowPageInput < ::Data + sig { returns(T.nilable(String)) } + def query; end + + sig { returns(T.nilable(String)) } + def next_page_token; end + + sig { returns(T.nilable(Integer)) } + def page_size; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::ListWorkflowPageInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::ListWorkflowPageInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::CountWorkflowsInput < ::Data + sig { returns(T.nilable(String)) } + def query; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::CountWorkflowsInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::CountWorkflowsInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::DescribeWorkflowInput < ::Data + sig { returns(String) } + def workflow_id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::DescribeWorkflowInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::DescribeWorkflowInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::FetchWorkflowHistoryEventsInput < ::Data + sig { returns(String) } + def workflow_id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(T::Boolean) } + def wait_new_event; end + + sig { returns(Integer) } + def event_filter_type; end + + sig { returns(T::Boolean) } + def skip_archival; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::FetchWorkflowHistoryEventsInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::FetchWorkflowHistoryEventsInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::SignalWorkflowInput < ::Data + sig { returns(String) } + def workflow_id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(String) } + def signal; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::SignalWorkflowInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::SignalWorkflowInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::QueryWorkflowInput < ::Data + sig { returns(String) } + def workflow_id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(String) } + def query; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(T.nilable(Integer)) } + def reject_condition; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::QueryWorkflowInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::QueryWorkflowInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::StartWorkflowUpdateInput < ::Data + sig { returns(String) } + def workflow_id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(String) } + def update_id; end + + sig { returns(String) } + def update; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(Integer) } + def wait_for_stage; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::StartWorkflowUpdateInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::StartWorkflowUpdateInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::PollWorkflowUpdateInput < ::Data + sig { returns(String) } + def workflow_id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(String) } + def update_id; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PollWorkflowUpdateInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PollWorkflowUpdateInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::CancelWorkflowInput < ::Data + sig { returns(String) } + def workflow_id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(T.nilable(String)) } + def first_execution_run_id; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::CancelWorkflowInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::CancelWorkflowInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::TerminateWorkflowInput < ::Data + sig { returns(String) } + def workflow_id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(T.nilable(String)) } + def first_execution_run_id; end + + sig { returns(T.nilable(String)) } + def reason; end + + sig { returns(T::Array[T.nilable(Object)]) } + def details; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::TerminateWorkflowInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::TerminateWorkflowInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::CreateScheduleInput < ::Data + sig { returns(String) } + def id; end + + sig { returns(Temporalio::Client::Schedule) } + def schedule; end + + sig { returns(T::Boolean) } + def trigger_immediately; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Backfill]) } + def backfills; end + + sig { returns(T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)])) } + def memo; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::CreateScheduleInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::CreateScheduleInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::ListSchedulesInput < ::Data + sig { returns(T.nilable(String)) } + def query; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::ListSchedulesInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::ListSchedulesInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::BackfillScheduleInput < ::Data + sig { returns(String) } + def id; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Backfill]) } + def backfills; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::BackfillScheduleInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::BackfillScheduleInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::DeleteScheduleInput < ::Data + sig { returns(String) } + def id; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::DeleteScheduleInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::DeleteScheduleInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::DescribeScheduleInput < ::Data + sig { returns(String) } + def id; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::DescribeScheduleInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::DescribeScheduleInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::PauseScheduleInput < ::Data + sig { returns(String) } + def id; end + + sig { returns(String) } + def note; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PauseScheduleInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::PauseScheduleInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::TriggerScheduleInput < ::Data + sig { returns(String) } + def id; end + + sig { returns(T.nilable(Integer)) } + def overlap; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::TriggerScheduleInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::TriggerScheduleInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::UnpauseScheduleInput < ::Data + sig { returns(String) } + def id; end + + sig { returns(String) } + def note; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UnpauseScheduleInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UnpauseScheduleInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::UpdateScheduleInput < ::Data + sig { returns(String) } + def id; end + + sig { returns(T.proc.params(arg0: Temporalio::Client::Schedule::Update::Input).returns(T.nilable(Temporalio::Client::Schedule::Update))) } + def updater; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UpdateScheduleInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::UpdateScheduleInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::HeartbeatAsyncActivityInput < ::Data + sig { returns(T.any(String, Temporalio::Client::ActivityIDReference)) } + def task_token_or_id_reference; end + + sig { returns(T::Array[T.nilable(Object)]) } + def details; end + + sig { returns(T.nilable(T::Array[Object])) } + def detail_hints; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::HeartbeatAsyncActivityInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::HeartbeatAsyncActivityInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::CompleteAsyncActivityInput < ::Data + sig { returns(T.any(String, Temporalio::Client::ActivityIDReference)) } + def task_token_or_id_reference; end + + sig { returns(T.nilable(Object)) } + def result; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::CompleteAsyncActivityInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::CompleteAsyncActivityInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::FailAsyncActivityInput < ::Data + sig { returns(T.any(String, Temporalio::Client::ActivityIDReference)) } + def task_token_or_id_reference; end + + sig { returns(Exception) } + def error; end + + sig { returns(T::Array[T.nilable(Object)]) } + def last_heartbeat_details; end + + sig { returns(T.nilable(T::Array[Object])) } + def last_heartbeat_detail_hints; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::FailAsyncActivityInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::FailAsyncActivityInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::ReportCancellationAsyncActivityInput < ::Data + sig { returns(T.any(String, Temporalio::Client::ActivityIDReference)) } + def task_token_or_id_reference; end + + sig { returns(T::Array[T.nilable(Object)]) } + def details; end + + sig { returns(T.nilable(T::Array[Object])) } + def detail_hints; end + + sig { returns(T.nilable(Temporalio::Client::RPCOptions)) } + def rpc_options; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::ReportCancellationAsyncActivityInput) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Interceptor::ReportCancellationAsyncActivityInput) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Interceptor::Outbound + sig { params(next_interceptor: Temporalio::Client::Interceptor::Outbound).void } + def initialize(next_interceptor); end + + sig { returns(Temporalio::Client::Interceptor::Outbound) } + attr_reader :next_interceptor + + sig { params(input: Temporalio::Client::Interceptor::StartWorkflowInput).returns(Temporalio::Client::WorkflowHandle) } + def start_workflow(input); end + + sig { params(input: Temporalio::Client::Interceptor::StartUpdateWithStartWorkflowInput).returns(Temporalio::Client::WorkflowUpdateHandle) } + def start_update_with_start_workflow(input); end + + sig { params(input: Temporalio::Client::Interceptor::SignalWithStartWorkflowInput).returns(Temporalio::Client::WorkflowHandle) } + def signal_with_start_workflow(input); end + + sig { params(input: Temporalio::Client::Interceptor::ListWorkflowPageInput).returns(Temporalio::Client::ListWorkflowPage) } + def list_workflow_page(input); end + + sig { params(input: Temporalio::Client::Interceptor::CountWorkflowsInput).returns(Temporalio::Client::WorkflowExecutionCount) } + def count_workflows(input); end + + sig { params(input: Temporalio::Client::Interceptor::DescribeWorkflowInput).returns(Temporalio::Client::WorkflowExecution::Description) } + def describe_workflow(input); end + + sig { params(input: Temporalio::Client::Interceptor::FetchWorkflowHistoryEventsInput).returns(T::Enumerator[Temporalio::Api::History::V1::HistoryEvent]) } + def fetch_workflow_history_events(input); end + + sig { params(input: Temporalio::Client::Interceptor::SignalWorkflowInput).void } + def signal_workflow(input); end + + sig { params(input: Temporalio::Client::Interceptor::QueryWorkflowInput).returns(T.nilable(Object)) } + def query_workflow(input); end + + sig { params(input: Temporalio::Client::Interceptor::StartWorkflowUpdateInput).returns(Temporalio::Client::WorkflowUpdateHandle) } + def start_workflow_update(input); end + + sig { params(input: Temporalio::Client::Interceptor::PollWorkflowUpdateInput).returns(Temporalio::Api::Update::V1::Outcome) } + def poll_workflow_update(input); end + + sig { params(input: Temporalio::Client::Interceptor::CancelWorkflowInput).void } + def cancel_workflow(input); end + + sig { params(input: Temporalio::Client::Interceptor::TerminateWorkflowInput).void } + def terminate_workflow(input); end + + sig { params(input: Temporalio::Client::Interceptor::CreateScheduleInput).returns(Temporalio::Client::ScheduleHandle) } + def create_schedule(input); end + + sig { params(input: Temporalio::Client::Interceptor::ListSchedulesInput).returns(T::Enumerator[Temporalio::Client::WorkflowExecution]) } + def list_schedules(input); end + + sig { params(input: Temporalio::Client::Interceptor::BackfillScheduleInput).void } + def backfill_schedule(input); end + + sig { params(input: Temporalio::Client::Interceptor::DeleteScheduleInput).void } + def delete_schedule(input); end + + sig { params(input: Temporalio::Client::Interceptor::DescribeScheduleInput).returns(Temporalio::Client::Schedule::Description) } + def describe_schedule(input); end + + sig { params(input: Temporalio::Client::Interceptor::PauseScheduleInput).void } + def pause_schedule(input); end + + sig { params(input: Temporalio::Client::Interceptor::TriggerScheduleInput).void } + def trigger_schedule(input); end + + sig { params(input: Temporalio::Client::Interceptor::UnpauseScheduleInput).void } + def unpause_schedule(input); end + + sig { params(input: Temporalio::Client::Interceptor::UpdateScheduleInput).void } + def update_schedule(input); end + + sig { params(input: Temporalio::Client::Interceptor::HeartbeatAsyncActivityInput).void } + def heartbeat_async_activity(input); end + + sig { params(input: Temporalio::Client::Interceptor::CompleteAsyncActivityInput).void } + def complete_async_activity(input); end + + sig { params(input: Temporalio::Client::Interceptor::FailAsyncActivityInput).void } + def fail_async_activity(input); end + + sig { params(input: Temporalio::Client::Interceptor::ReportCancellationAsyncActivityInput).void } + def report_cancellation_async_activity(input); end +end diff --git a/temporalio/rbi/temporalio/client/plugin.rbi b/temporalio/rbi/temporalio/client/plugin.rbi new file mode 100644 index 00000000..147f9ecd --- /dev/null +++ b/temporalio/rbi/temporalio/client/plugin.rbi @@ -0,0 +1,20 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Client::Plugin + sig { returns(String) } + def name; end + + sig { params(options: Temporalio::Client::Options).returns(Temporalio::Client::Options) } + def configure_client(options); end + + sig do + params( + options: Temporalio::Client::Connection::Options, + next_call: T.proc.params(arg0: Temporalio::Client::Connection::Options).returns(Temporalio::Client::Connection) + ).returns(Temporalio::Client::Connection) + end + def connect_client(options, next_call); end +end diff --git a/temporalio/rbi/temporalio/client/schedule.rbi b/temporalio/rbi/temporalio/client/schedule.rbi new file mode 100644 index 00000000..1cfc366e --- /dev/null +++ b/temporalio/rbi/temporalio/client/schedule.rbi @@ -0,0 +1,680 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::Schedule < ::Data + sig do + params( + action: Temporalio::Client::Schedule::Action, + spec: Temporalio::Client::Schedule::Spec, + policy: Temporalio::Client::Schedule::Policy, + state: Temporalio::Client::Schedule::State + ).void + end + def initialize(action:, spec:, policy: T.unsafe(nil), state: T.unsafe(nil)); end + + sig { returns(Temporalio::Client::Schedule::Action) } + def action; end + + sig { returns(Temporalio::Client::Schedule::Spec) } + def spec; end + + sig { returns(Temporalio::Client::Schedule::Policy) } + def policy; end + + sig { returns(Temporalio::Client::Schedule::State) } + def state; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Client::Schedule) } + def with(**kwargs); end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +module Temporalio::Client::Schedule::Action; end + +class Temporalio::Client::Schedule::Action::StartWorkflow < ::Data + include Temporalio::Client::Schedule::Action + + sig { returns(T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, String)) } + def workflow; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(String) } + def id; end + + sig { returns(String) } + def task_queue; end + + sig { returns(T.nilable(String)) } + def static_summary; end + + sig { returns(T.nilable(String)) } + def static_details; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def execution_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def run_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def task_timeout; end + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + def retry_policy; end + + sig { returns(T.nilable(T::Hash[String, T.nilable(Object)])) } + def memo; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + sig { returns(Temporalio::Priority) } + def priority; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(T::Hash[String, T.nilable(Object)])) } + def headers; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Client::Schedule::Action::StartWorkflow) } + def with(**kwargs); end + + class << self + sig do + params( + workflow: T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, String), + args: T.nilable(Object), + id: String, + task_queue: String, + static_summary: T.nilable(String), + static_details: T.nilable(String), + execution_timeout: T.nilable(T.any(Integer, Float)), + run_timeout: T.nilable(T.any(Integer, Float)), + task_timeout: T.nilable(T.any(Integer, Float)), + retry_policy: T.nilable(Temporalio::RetryPolicy), + memo: T.nilable(T::Hash[String, T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + headers: T.nilable(T::Hash[String, T.nilable(Object)]) + ).returns(Temporalio::Client::Schedule::Action::StartWorkflow) + end + def new(workflow, *args, id:, task_queue:, static_summary: T.unsafe(nil), static_details: T.unsafe(nil), execution_timeout: T.unsafe(nil), run_timeout: T.unsafe(nil), task_timeout: T.unsafe(nil), retry_policy: T.unsafe(nil), memo: T.unsafe(nil), search_attributes: T.unsafe(nil), priority: T.unsafe(nil), arg_hints: T.unsafe(nil), headers: T.unsafe(nil)); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Action::StartWorkflow) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +module Temporalio::Client::Schedule::OverlapPolicy + SKIP = T.let(T.unsafe(nil), Integer) + BUFFER_ONE = T.let(T.unsafe(nil), Integer) + BUFFER_ALL = T.let(T.unsafe(nil), Integer) + CANCEL_OTHER = T.let(T.unsafe(nil), Integer) + TERMINATE_OTHER = T.let(T.unsafe(nil), Integer) + ALLOW_ALL = T.let(T.unsafe(nil), Integer) +end + +class Temporalio::Client::Schedule::Backfill < ::Data + sig { params(start_at: Time, end_at: Time, overlap: T.nilable(Integer)).void } + def initialize(start_at:, end_at:, overlap: T.unsafe(nil)); end + + sig { returns(Time) } + def start_at; end + + sig { returns(Time) } + def end_at; end + + sig { returns(T.nilable(Integer)) } + def overlap; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Backfill) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Backfill) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +module Temporalio::Client::Schedule::ActionExecution; end + +class Temporalio::Client::Schedule::ActionExecution::StartWorkflow < ::Data + include Temporalio::Client::Schedule::ActionExecution + + sig { params(raw_execution: Temporalio::Api::Common::V1::WorkflowExecution).void } + def initialize(raw_execution:); end + + sig { returns(String) } + def workflow_id; end + + sig { returns(String) } + def first_execution_run_id; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::ActionExecution::StartWorkflow) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::ActionExecution::StartWorkflow) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::ActionResult < ::Data + sig { params(raw_result: Temporalio::Api::Schedule::V1::ScheduleActionResult).void } + def initialize(raw_result:); end + + sig { returns(Time) } + def scheduled_at; end + + sig { returns(Time) } + def started_at; end + + sig { returns(Temporalio::Client::Schedule::ActionExecution) } + def action; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::ActionResult) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::ActionResult) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Spec < ::Data + sig do + params( + calendars: T::Array[Temporalio::Client::Schedule::Spec::Calendar], + intervals: T::Array[Temporalio::Client::Schedule::Spec::Interval], + cron_expressions: T::Array[String], + skip: T::Array[Temporalio::Client::Schedule::Spec::Calendar], + start_at: T.nilable(Time), + end_at: T.nilable(Time), + jitter: T.nilable(Float), + time_zone_name: T.nilable(String) + ).void + end + def initialize( + calendars: T.unsafe(nil), + intervals: T.unsafe(nil), + cron_expressions: T.unsafe(nil), + skip: T.unsafe(nil), + start_at: T.unsafe(nil), + end_at: T.unsafe(nil), + jitter: T.unsafe(nil), + time_zone_name: T.unsafe(nil) + ); end + + sig { returns(T::Array[Temporalio::Client::Schedule::Spec::Calendar]) } + def calendars; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Spec::Interval]) } + def intervals; end + + sig { returns(T::Array[String]) } + def cron_expressions; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Spec::Calendar]) } + def skip; end + + sig { returns(T.nilable(Time)) } + def start_at; end + + sig { returns(T.nilable(Time)) } + def end_at; end + + sig { returns(T.nilable(Numeric)) } + def jitter; end + + sig { returns(T.nilable(String)) } + def time_zone_name; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Client::Schedule::Spec) } + def with(**kwargs); end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Spec) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Spec) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Spec::Calendar < ::Data + sig do + params( + second: T::Array[Temporalio::Client::Schedule::Range], + minute: T::Array[Temporalio::Client::Schedule::Range], + hour: T::Array[Temporalio::Client::Schedule::Range], + day_of_month: T::Array[Temporalio::Client::Schedule::Range], + month: T::Array[Temporalio::Client::Schedule::Range], + year: T::Array[Temporalio::Client::Schedule::Range], + day_of_week: T::Array[Temporalio::Client::Schedule::Range], + comment: T.nilable(String) + ).void + end + def initialize( + second: T.unsafe(nil), + minute: T.unsafe(nil), + hour: T.unsafe(nil), + day_of_month: T.unsafe(nil), + month: T.unsafe(nil), + year: T.unsafe(nil), + day_of_week: T.unsafe(nil), + comment: T.unsafe(nil) + ); end + + sig { returns(T::Array[Temporalio::Client::Schedule::Range]) } + def second; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Range]) } + def minute; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Range]) } + def hour; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Range]) } + def day_of_month; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Range]) } + def month; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Range]) } + def year; end + + sig { returns(T::Array[Temporalio::Client::Schedule::Range]) } + def day_of_week; end + + sig { returns(T.nilable(String)) } + def comment; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Spec::Calendar) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Spec::Calendar) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Spec::Interval < ::Data + sig { params(every: T.any(Integer, Float), offset: T.nilable(T.any(Integer, Float))).void } + def initialize(every:, offset: T.unsafe(nil)); end + + sig { returns(T.any(Integer, Float)) } + def every; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def offset; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Spec::Interval) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Spec::Interval) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Range < ::Data + sig { returns(Integer) } + def start; end + + sig { returns(Integer) } + def finish; end + + sig { returns(Integer) } + def step; end + + class << self + sig { params(start: Integer, finish: Integer, step: Integer).returns(Temporalio::Client::Schedule::Range) } + def new(start, finish = T.unsafe(nil), step = T.unsafe(nil)); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Range) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Policy < ::Data + sig do + params( + overlap: Integer, + catchup_window: T.any(Integer, Float), + pause_on_failure: T::Boolean + ).void + end + def initialize(overlap: T.unsafe(nil), catchup_window: T.unsafe(nil), pause_on_failure: T.unsafe(nil)); end + + sig { returns(Integer) } + def overlap; end + + sig { returns(T.any(Integer, Float)) } + def catchup_window; end + + sig { returns(T::Boolean) } + def pause_on_failure; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Policy) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Policy) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::State < ::Data + sig do + params( + note: T.nilable(String), + paused: T::Boolean, + limited_actions: T::Boolean, + remaining_actions: Integer + ).void + end + def initialize(note: T.unsafe(nil), paused: T.unsafe(nil), limited_actions: T.unsafe(nil), remaining_actions: T.unsafe(nil)); end + + sig { returns(T.nilable(String)) } + def note; end + + sig { returns(T::Boolean) } + def paused; end + + sig { returns(T::Boolean) } + def limited_actions; end + + sig { returns(Integer) } + def remaining_actions; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::State) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::State) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Description < ::Data + sig { params(id: String, raw_description: Temporalio::Api::WorkflowService::V1::DescribeScheduleResponse, data_converter: Temporalio::Converters::DataConverter).void } + def initialize(id:, raw_description:, data_converter:); end + + sig { returns(String) } + def id; end + + sig { returns(Temporalio::Client::Schedule) } + def schedule; end + + sig { returns(Temporalio::Client::Schedule::Info) } + def info; end + + sig { returns(Temporalio::Api::WorkflowService::V1::DescribeScheduleResponse) } + def raw_description; end + + sig { returns(T.nilable(T::Hash[String, T.nilable(Object)])) } + def memo; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Description) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Description) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Info < ::Data + sig { params(raw_info: Temporalio::Api::Schedule::V1::ScheduleInfo).void } + def initialize(raw_info:); end + + sig { returns(Integer) } + def num_actions; end + + sig { returns(Integer) } + def num_actions_missed_catchup_window; end + + sig { returns(Integer) } + def num_actions_skipped_overlap; end + + sig { returns(T::Array[Temporalio::Client::Schedule::ActionExecution]) } + def running_actions; end + + sig { returns(T::Array[Temporalio::Client::Schedule::ActionResult]) } + def recent_actions; end + + sig { returns(T::Array[Time]) } + def next_action_times; end + + sig { returns(Time) } + def created_at; end + + sig { returns(T.nilable(Time)) } + def last_updated_at; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Info) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Info) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Update < ::Data + sig { params(schedule: Temporalio::Client::Schedule, search_attributes: T.nilable(Temporalio::SearchAttributes)).void } + def initialize(schedule:, search_attributes: T.unsafe(nil)); end + + sig { returns(Temporalio::Client::Schedule) } + def schedule; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Update) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Update) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::Update::Input < ::Data + sig { returns(Temporalio::Client::Schedule::Description) } + def description; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Update::Input) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::Update::Input) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +module Temporalio::Client::Schedule::List; end + +module Temporalio::Client::Schedule::List::Action; end + +class Temporalio::Client::Schedule::List::Action::StartWorkflow < ::Data + include Temporalio::Client::Schedule::List::Action + + sig { returns(String) } + def workflow; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::Action::StartWorkflow) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::Action::StartWorkflow) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::List::Description < ::Data + sig { params(raw_entry: Temporalio::Api::Schedule::V1::ScheduleListEntry, data_converter: Temporalio::Converters::DataConverter).void } + def initialize(raw_entry:, data_converter:); end + + sig { returns(String) } + def id; end + + sig { returns(Temporalio::Client::Schedule::List::Schedule) } + def schedule; end + + sig { returns(Temporalio::Client::Schedule::List::Info) } + def info; end + + sig { returns(Temporalio::Api::Schedule::V1::ScheduleListEntry) } + def raw_entry; end + + sig { returns(T.nilable(T::Hash[String, T.nilable(Object)])) } + def memo; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::Description) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::Description) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::List::Schedule < ::Data + sig { params(raw_info: Temporalio::Api::Schedule::V1::ScheduleListInfo).void } + def initialize(raw_info:); end + + sig { returns(Temporalio::Client::Schedule::List::Action) } + def action; end + + sig { returns(Temporalio::Client::Schedule::Spec) } + def spec; end + + sig { returns(Temporalio::Client::Schedule::List::State) } + def state; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::Schedule) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::Schedule) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::List::Info < ::Data + sig { params(raw_info: Temporalio::Api::Schedule::V1::ScheduleListInfo).void } + def initialize(raw_info:); end + + sig { returns(T::Array[Temporalio::Client::Schedule::ActionResult]) } + def recent_actions; end + + sig { returns(T::Array[Time]) } + def next_action_times; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::Info) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::Info) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end + +class Temporalio::Client::Schedule::List::State < ::Data + sig { params(raw_info: Temporalio::Api::Schedule::V1::ScheduleListInfo).void } + def initialize(raw_info:); end + + sig { returns(T.nilable(String)) } + def note; end + + sig { returns(T::Boolean) } + def paused; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::State) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::Schedule::List::State) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end diff --git a/temporalio/rbi/temporalio/client/schedule_handle.rbi b/temporalio/rbi/temporalio/client/schedule_handle.rbi new file mode 100644 index 00000000..4f80092d --- /dev/null +++ b/temporalio/rbi/temporalio/client/schedule_handle.rbi @@ -0,0 +1,43 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::ScheduleHandle + sig { params(client: Temporalio::Client, id: String).void } + def initialize(client:, id:); end + + sig { returns(String) } + attr_reader :id + + sig do + params( + backfills: Temporalio::Client::Schedule::Backfill, + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).void + end + def backfill(*backfills, rpc_options: T.unsafe(nil)); end + + sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void } + def delete(rpc_options: T.unsafe(nil)); end + + sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).returns(Temporalio::Client::Schedule::Description) } + def describe(rpc_options: T.unsafe(nil)); end + + sig { params(note: String, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void } + def pause(note: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig { params(overlap: T.nilable(Integer), rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void } + def trigger(overlap: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig { params(note: String, rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void } + def unpause(note: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + rpc_options: T.nilable(Temporalio::Client::RPCOptions), + updater: T.proc.params(arg0: Temporalio::Client::Schedule::Update::Input).returns(T.nilable(Temporalio::Client::Schedule::Update)) + ).void + end + def update(rpc_options: T.unsafe(nil), &updater); end +end diff --git a/temporalio/rbi/temporalio/client/with_start_workflow_operation.rbi b/temporalio/rbi/temporalio/client/with_start_workflow_operation.rbi new file mode 100644 index 00000000..e222b98a --- /dev/null +++ b/temporalio/rbi/temporalio/client/with_start_workflow_operation.rbi @@ -0,0 +1,129 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::WithStartWorkflowOperation + sig do + params( + workflow: T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, String), + args: T.nilable(Object), + id: String, + task_queue: String, + static_summary: T.nilable(String), + static_details: T.nilable(String), + execution_timeout: T.nilable(T.any(Integer, Float)), + run_timeout: T.nilable(T.any(Integer, Float)), + task_timeout: T.nilable(T.any(Integer, Float)), + id_reuse_policy: Integer, + id_conflict_policy: Integer, + retry_policy: T.nilable(Temporalio::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + start_delay: T.nilable(T.any(Integer, Float)), + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + headers: T.nilable(T::Hash[String, T.nilable(Object)]) + ).void + end + def initialize( + workflow, + *args, + id:, + task_queue:, + static_summary: T.unsafe(nil), + static_details: T.unsafe(nil), + execution_timeout: T.unsafe(nil), + run_timeout: T.unsafe(nil), + task_timeout: T.unsafe(nil), + id_reuse_policy: T.unsafe(nil), + id_conflict_policy: T.unsafe(nil), + retry_policy: T.unsafe(nil), + cron_schedule: T.unsafe(nil), + memo: T.unsafe(nil), + search_attributes: T.unsafe(nil), + start_delay: T.unsafe(nil), + priority: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil), + headers: T.unsafe(nil) + ); end + + sig { returns(Temporalio::Client::WithStartWorkflowOperation::Options) } + attr_accessor :options + + sig { params(wait: T::Boolean).returns(T.nilable(Temporalio::Client::WorkflowHandle)) } + def workflow_handle(wait: T.unsafe(nil)); end +end + +class Temporalio::Client::WithStartWorkflowOperation::Options < ::Data + sig { returns(String) } + def workflow; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(String) } + def id; end + + sig { returns(String) } + def task_queue; end + + sig { returns(T.nilable(String)) } + def static_summary; end + + sig { returns(T.nilable(String)) } + def static_details; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def execution_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def run_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def task_timeout; end + + sig { returns(Integer) } + def id_reuse_policy; end + + sig { returns(Integer) } + def id_conflict_policy; end + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + def retry_policy; end + + sig { returns(T.nilable(String)) } + def cron_schedule; end + + sig { returns(T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)])) } + def memo; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def start_delay; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Client::WithStartWorkflowOperation::Options) } + def new(*args); end + + sig { params(args: T.untyped).returns(Temporalio::Client::WithStartWorkflowOperation::Options) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + end +end diff --git a/temporalio/rbi/temporalio/client/workflow_execution.rbi b/temporalio/rbi/temporalio/client/workflow_execution.rbi new file mode 100644 index 00000000..72cfb922 --- /dev/null +++ b/temporalio/rbi/temporalio/client/workflow_execution.rbi @@ -0,0 +1,65 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::WorkflowExecution + sig { params(raw_info: Temporalio::Api::Workflow::V1::WorkflowExecutionInfo, data_converter: Temporalio::Converters::DataConverter).void } + def initialize(raw_info, data_converter); end + + sig { returns(Temporalio::Api::Workflow::V1::WorkflowExecutionInfo) } + attr_reader :raw_info + + sig { returns(T.nilable(Time)) } + def close_time; end + + sig { returns(T.nilable(Time)) } + def execution_time; end + + sig { returns(Integer) } + def history_length; end + + sig { returns(String) } + def id; end + + sig { returns(T.nilable(T::Hash[String, T.nilable(Object)])) } + def memo; end + + sig { returns(T.nilable(String)) } + def parent_id; end + + sig { returns(T.nilable(String)) } + def parent_run_id; end + + sig { returns(String) } + def run_id; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + sig { returns(Time) } + def start_time; end + + sig { returns(Integer) } + def status; end + + sig { returns(String) } + def task_queue; end + + sig { returns(String) } + def workflow_type; end +end + +class Temporalio::Client::WorkflowExecution::Description < ::Temporalio::Client::WorkflowExecution + sig { params(raw_description: Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse, data_converter: Temporalio::Converters::DataConverter).void } + def initialize(raw_description, data_converter); end + + sig { returns(Temporalio::Api::WorkflowService::V1::DescribeWorkflowExecutionResponse) } + attr_reader :raw_description + + sig { returns(T.nilable(String)) } + def static_summary; end + + sig { returns(T.nilable(String)) } + def static_details; end +end diff --git a/temporalio/rbi/temporalio/client/workflow_execution_count.rbi b/temporalio/rbi/temporalio/client/workflow_execution_count.rbi new file mode 100644 index 00000000..d36fde0b --- /dev/null +++ b/temporalio/rbi/temporalio/client/workflow_execution_count.rbi @@ -0,0 +1,26 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::WorkflowExecutionCount + sig { params(count: Integer, groups: T::Array[Temporalio::Client::WorkflowExecutionCount::AggregationGroup]).void } + def initialize(count, groups); end + + sig { returns(Integer) } + attr_reader :count + + sig { returns(T::Array[Temporalio::Client::WorkflowExecutionCount::AggregationGroup]) } + attr_reader :groups +end + +class Temporalio::Client::WorkflowExecutionCount::AggregationGroup + sig { params(count: Integer, group_values: T::Array[T.nilable(Object)]).void } + def initialize(count, group_values); end + + sig { returns(Integer) } + attr_reader :count + + sig { returns(T::Array[T.nilable(Object)]) } + attr_reader :group_values +end diff --git a/temporalio/rbi/temporalio/client/workflow_execution_status.rbi b/temporalio/rbi/temporalio/client/workflow_execution_status.rbi new file mode 100644 index 00000000..c235c782 --- /dev/null +++ b/temporalio/rbi/temporalio/client/workflow_execution_status.rbi @@ -0,0 +1,14 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Client::WorkflowExecutionStatus + RUNNING = T.let(T.unsafe(nil), Integer) + COMPLETED = T.let(T.unsafe(nil), Integer) + FAILED = T.let(T.unsafe(nil), Integer) + CANCELED = T.let(T.unsafe(nil), Integer) + TERMINATED = T.let(T.unsafe(nil), Integer) + CONTINUED_AS_NEW = T.let(T.unsafe(nil), Integer) + TIMED_OUT = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/client/workflow_handle.rbi b/temporalio/rbi/temporalio/client/workflow_handle.rbi new file mode 100644 index 00000000..fbc1d485 --- /dev/null +++ b/temporalio/rbi/temporalio/client/workflow_handle.rbi @@ -0,0 +1,151 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::WorkflowHandle + sig do + params( + client: Temporalio::Client, + id: String, + run_id: T.nilable(String), + result_run_id: T.nilable(String), + first_execution_run_id: T.nilable(String), + result_hint: T.nilable(Object) + ).void + end + def initialize(client:, id:, run_id:, result_run_id:, first_execution_run_id:, result_hint:); end + + sig { returns(String) } + attr_reader :id + + sig { returns(T.nilable(String)) } + attr_reader :run_id + + sig { returns(T.nilable(String)) } + attr_reader :result_run_id + + sig { returns(T.nilable(String)) } + attr_reader :first_execution_run_id + + sig { returns(T.nilable(Object)) } + attr_reader :result_hint + + sig do + params( + follow_runs: T::Boolean, + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T.nilable(Object)) + end + def result(follow_runs: T.unsafe(nil), result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::WorkflowExecution::Description) + end + def describe(rpc_options: T.unsafe(nil)); end + + sig do + params( + event_filter_type: Integer, + skip_archival: T::Boolean, + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::WorkflowHistory) + end + def fetch_history(event_filter_type: T.unsafe(nil), skip_archival: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + wait_new_event: T::Boolean, + event_filter_type: Integer, + skip_archival: T::Boolean, + specific_run_id: T.nilable(String), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T::Enumerator[Temporalio::Api::History::V1::HistoryEvent]) + end + def fetch_history_events( + wait_new_event: T.unsafe(nil), + event_filter_type: T.unsafe(nil), + skip_archival: T.unsafe(nil), + specific_run_id: T.unsafe(nil), + rpc_options: T.unsafe(nil) + ); end + + sig do + params( + signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String), + args: T.nilable(Object), + arg_hints: T.nilable(T::Array[Object]), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).void + end + def signal(signal, *args, arg_hints: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + query: T.any(Temporalio::Workflow::Definition::Query, Symbol, String), + args: T.nilable(Object), + reject_condition: T.nilable(Integer), + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T.nilable(Object)) + end + def query(query, *args, reject_condition: T.unsafe(nil), arg_hints: T.unsafe(nil), result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + update: T.any(Temporalio::Workflow::Definition::Update, Symbol, String), + args: T.nilable(Object), + wait_for_stage: Integer, + id: String, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::WorkflowUpdateHandle) + end + def start_update( + update, + *args, + wait_for_stage:, + id: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil), + rpc_options: T.unsafe(nil) + ); end + + sig do + params( + update: T.any(Temporalio::Workflow::Definition::Update, Symbol, String), + args: T.nilable(Object), + id: String, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T.nilable(Object)) + end + def execute_update(update, *args, id: T.unsafe(nil), arg_hints: T.unsafe(nil), result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end + + sig do + params( + id: String, + specific_run_id: T.nilable(String), + result_hint: T.nilable(Object) + ).returns(Temporalio::Client::WorkflowUpdateHandle) + end + def update_handle(id, specific_run_id: T.unsafe(nil), result_hint: T.unsafe(nil)); end + + sig { params(rpc_options: T.nilable(Temporalio::Client::RPCOptions)).void } + def cancel(rpc_options: T.unsafe(nil)); end + + sig do + params( + reason: T.nilable(String), + details: T::Array[T.nilable(Object)], + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).void + end + def terminate(reason = T.unsafe(nil), details: T.unsafe(nil), rpc_options: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/client/workflow_query_reject_condition.rbi b/temporalio/rbi/temporalio/client/workflow_query_reject_condition.rbi new file mode 100644 index 00000000..51c4f69b --- /dev/null +++ b/temporalio/rbi/temporalio/client/workflow_query_reject_condition.rbi @@ -0,0 +1,10 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Client::WorkflowQueryRejectCondition + NONE = T.let(T.unsafe(nil), Integer) + NOT_OPEN = T.let(T.unsafe(nil), Integer) + NOT_COMPLETED_CLEANLY = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/client/workflow_update_handle.rbi b/temporalio/rbi/temporalio/client/workflow_update_handle.rbi new file mode 100644 index 00000000..975354ab --- /dev/null +++ b/temporalio/rbi/temporalio/client/workflow_update_handle.rbi @@ -0,0 +1,41 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Client::WorkflowUpdateHandle + sig do + params( + client: Temporalio::Client, + id: String, + workflow_id: String, + workflow_run_id: T.nilable(String), + known_outcome: T.nilable(Object), + result_hint: T.nilable(Object) + ).void + end + def initialize(client:, id:, workflow_id:, workflow_run_id:, known_outcome:, result_hint:); end + + sig { returns(String) } + attr_reader :id + + sig { returns(String) } + attr_reader :workflow_id + + sig { returns(T.nilable(String)) } + attr_reader :workflow_run_id + + sig { returns(T.nilable(Object)) } + attr_reader :result_hint + + sig { returns(T::Boolean) } + def result_obtained?; end + + sig do + params( + result_hint: T.nilable(Object), + rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(T.nilable(Object)) + end + def result(result_hint: T.unsafe(nil), rpc_options: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/client/workflow_update_wait_stage.rbi b/temporalio/rbi/temporalio/client/workflow_update_wait_stage.rbi new file mode 100644 index 00000000..63f0ddc0 --- /dev/null +++ b/temporalio/rbi/temporalio/client/workflow_update_wait_stage.rbi @@ -0,0 +1,10 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Client::WorkflowUpdateWaitStage + ADMITTED = T.let(T.unsafe(nil), Integer) + ACCEPTED = T.let(T.unsafe(nil), Integer) + COMPLETED = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/common_enums.rbi b/temporalio/rbi/temporalio/common_enums.rbi new file mode 100644 index 00000000..cf52cf04 --- /dev/null +++ b/temporalio/rbi/temporalio/common_enums.rbi @@ -0,0 +1,48 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::WorkflowIDReusePolicy + ALLOW_DUPLICATE = T.let(T.unsafe(nil), Integer) + + ALLOW_DUPLICATE_FAILED_ONLY = T.let(T.unsafe(nil), Integer) + + REJECT_DUPLICATE = T.let(T.unsafe(nil), Integer) + + TERMINATE_IF_RUNNING = T.let(T.unsafe(nil), Integer) +end + +module Temporalio::WorkflowIDConflictPolicy + UNSPECIFIED = T.let(T.unsafe(nil), Integer) + + FAIL = T.let(T.unsafe(nil), Integer) + + USE_EXISTING = T.let(T.unsafe(nil), Integer) + + TERMINATE_EXISTING = T.let(T.unsafe(nil), Integer) +end + +module Temporalio::ContinueAsNewVersioningBehavior + UNSPECIFIED = T.let(T.unsafe(nil), Integer) + + AUTO_UPGRADE = T.let(T.unsafe(nil), Integer) +end + +module Temporalio::SuggestContinueAsNewReason + UNSPECIFIED = T.let(T.unsafe(nil), Integer) + + HISTORY_SIZE_TOO_LARGE = T.let(T.unsafe(nil), Integer) + + TOO_MANY_HISTORY_EVENTS = T.let(T.unsafe(nil), Integer) + + TOO_MANY_UPDATES = T.let(T.unsafe(nil), Integer) +end + +module Temporalio::VersioningBehavior + UNSPECIFIED = T.let(T.unsafe(nil), Integer) + + PINNED = T.let(T.unsafe(nil), Integer) + + AUTO_UPGRADE = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/contrib/open_telemetry.rbi b/temporalio/rbi/temporalio/contrib/open_telemetry.rbi new file mode 100644 index 00000000..cc4717d3 --- /dev/null +++ b/temporalio/rbi/temporalio/contrib/open_telemetry.rbi @@ -0,0 +1,76 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Contrib; end + +module Temporalio::Contrib::OpenTelemetry; end + +class Temporalio::Contrib::OpenTelemetry::TracingInterceptor + include Temporalio::Client::Interceptor + include Temporalio::Worker::Interceptor::Activity + include Temporalio::Worker::Interceptor::Workflow + + extend T::Sig + + sig { returns(T.anything) } + attr_reader :tracer + + sig do + params( + tracer: T.anything, + header_key: String, + propagator: T.anything, + always_create_workflow_spans: T::Boolean + ).void + end + def initialize(tracer, header_key: T.unsafe(nil), propagator: T.unsafe(nil), always_create_workflow_spans: T.unsafe(nil)); end +end + +module Temporalio::Contrib::OpenTelemetry::Workflow + class << self + extend T::Sig + + sig do + type_parameters(:T) + .params( + name: String, + attributes: T::Hash[T.anything, T.anything], + links: T.nilable(T::Array[T.anything]), + kind: T.nilable(Symbol), + exception: T.nilable(Exception), + even_during_replay: T::Boolean, + block: T.proc.returns(T.type_parameter(:T)) + ).returns(T.type_parameter(:T)) + end + def with_completed_span( + name, + attributes: T.unsafe(nil), + links: T.unsafe(nil), + kind: T.unsafe(nil), + exception: T.unsafe(nil), + even_during_replay: T.unsafe(nil), + &block + ); end + + sig do + params( + name: String, + attributes: T::Hash[T.anything, T.anything], + links: T.nilable(T::Array[T.anything]), + kind: T.nilable(Symbol), + exception: T.nilable(Exception), + even_during_replay: T::Boolean + ).returns(T.anything) + end + def completed_span( + name, + attributes: T.unsafe(nil), + links: T.unsafe(nil), + kind: T.unsafe(nil), + exception: T.unsafe(nil), + even_during_replay: T.unsafe(nil) + ); end + end +end diff --git a/temporalio/rbi/temporalio/converters.rbi b/temporalio/rbi/temporalio/converters.rbi new file mode 100644 index 00000000..21554aa8 --- /dev/null +++ b/temporalio/rbi/temporalio/converters.rbi @@ -0,0 +1,6 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Converters; end diff --git a/temporalio/rbi/temporalio/converters/data_converter.rbi b/temporalio/rbi/temporalio/converters/data_converter.rbi new file mode 100644 index 00000000..c6282555 --- /dev/null +++ b/temporalio/rbi/temporalio/converters/data_converter.rbi @@ -0,0 +1,47 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::DataConverter + extend T::Sig + + sig { returns(Temporalio::Converters::PayloadConverter) } + attr_reader :payload_converter + + sig { returns(Temporalio::Converters::FailureConverter) } + attr_reader :failure_converter + + sig { returns(T.nilable(Temporalio::Converters::PayloadCodec)) } + attr_reader :payload_codec + + sig { returns(Temporalio::Converters::DataConverter) } + def self.default; end + + sig do + params( + payload_converter: Temporalio::Converters::PayloadConverter, + failure_converter: Temporalio::Converters::FailureConverter, + payload_codec: T.nilable(Temporalio::Converters::PayloadCodec) + ).void + end + def initialize(payload_converter: T.unsafe(nil), failure_converter: T.unsafe(nil), payload_codec: T.unsafe(nil)); end + + sig { params(value: T.nilable(Object), hint: T.nilable(Object)).returns(Temporalio::Api::Common::V1::Payload) } + def to_payload(value, hint: T.unsafe(nil)); end + + sig { params(values: T::Array[T.nilable(Object)], hints: T.nilable(T::Array[Object])).returns(Temporalio::Api::Common::V1::Payloads) } + def to_payloads(values, hints: T.unsafe(nil)); end + + sig { params(payload: Temporalio::Api::Common::V1::Payload, hint: T.nilable(Object)).returns(T.nilable(Object)) } + def from_payload(payload, hint: T.unsafe(nil)); end + + sig { params(payloads: T.nilable(Temporalio::Api::Common::V1::Payloads), hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) } + def from_payloads(payloads, hints: T.unsafe(nil)); end + + sig { params(error: Exception).returns(Temporalio::Api::Failure::V1::Failure) } + def to_failure(error); end + + sig { params(failure: Temporalio::Api::Failure::V1::Failure).returns(Exception) } + def from_failure(failure); end +end diff --git a/temporalio/rbi/temporalio/converters/failure_converter.rbi b/temporalio/rbi/temporalio/converters/failure_converter.rbi new file mode 100644 index 00000000..dfc3565f --- /dev/null +++ b/temporalio/rbi/temporalio/converters/failure_converter.rbi @@ -0,0 +1,23 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::FailureConverter + extend T::Sig + + sig { returns(Temporalio::Converters::FailureConverter) } + def self.default; end + + sig { params(encode_common_attributes: T::Boolean).void } + def initialize(encode_common_attributes: T.unsafe(nil)); end + + sig { returns(T::Boolean) } + attr_reader :encode_common_attributes + + sig { params(error: Exception, converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)).returns(Temporalio::Api::Failure::V1::Failure) } + def to_failure(error, converter); end + + sig { params(failure: Temporalio::Api::Failure::V1::Failure, converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter)).returns(Exception) } + def from_failure(failure, converter); end +end diff --git a/temporalio/rbi/temporalio/converters/payload_codec.rbi b/temporalio/rbi/temporalio/converters/payload_codec.rbi new file mode 100644 index 00000000..7bc1daa0 --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_codec.rbi @@ -0,0 +1,14 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadCodec + extend T::Sig + + sig { params(payloads: T::Enumerable[Temporalio::Api::Common::V1::Payload]).returns(T::Array[Temporalio::Api::Common::V1::Payload]) } + def encode(payloads); end + + sig { params(payloads: T::Enumerable[Temporalio::Api::Common::V1::Payload]).returns(T::Array[Temporalio::Api::Common::V1::Payload]) } + def decode(payloads); end +end diff --git a/temporalio/rbi/temporalio/converters/payload_converter.rbi b/temporalio/rbi/temporalio/converters/payload_converter.rbi new file mode 100644 index 00000000..4d961c7f --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_converter.rbi @@ -0,0 +1,31 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadConverter + extend T::Sig + + sig { returns(Temporalio::Converters::PayloadConverter::Composite) } + def self.default; end + + sig do + params( + json_parse_options: T::Hash[Symbol, Object], + json_generate_options: T::Hash[Symbol, Object] + ).returns(Temporalio::Converters::PayloadConverter::Composite) + end + def self.new_with_defaults(json_parse_options: T.unsafe(nil), json_generate_options: T.unsafe(nil)); end + + sig { params(value: T.nilable(Object), hint: T.nilable(Object)).returns(Temporalio::Api::Common::V1::Payload) } + def to_payload(value, hint: T.unsafe(nil)); end + + sig { params(values: T::Array[T.nilable(Object)], hints: T.nilable(T::Array[Object])).returns(Temporalio::Api::Common::V1::Payloads) } + def to_payloads(values, hints: T.unsafe(nil)); end + + sig { params(payload: Temporalio::Api::Common::V1::Payload, hint: T.nilable(Object)).returns(T.nilable(Object)) } + def from_payload(payload, hint: T.unsafe(nil)); end + + sig { params(payloads: T.nilable(Temporalio::Api::Common::V1::Payloads), hints: T.nilable(T::Array[Object])).returns(T::Array[T.nilable(Object)]) } + def from_payloads(payloads, hints: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/converters/payload_converter/binary_null.rbi b/temporalio/rbi/temporalio/converters/payload_converter/binary_null.rbi new file mode 100644 index 00000000..afa51366 --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_converter/binary_null.rbi @@ -0,0 +1,8 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadConverter::BinaryNull < ::Temporalio::Converters::PayloadConverter::Encoding + ENCODING = T.let(T.unsafe(nil), String) +end diff --git a/temporalio/rbi/temporalio/converters/payload_converter/binary_plain.rbi b/temporalio/rbi/temporalio/converters/payload_converter/binary_plain.rbi new file mode 100644 index 00000000..9c15e6d5 --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_converter/binary_plain.rbi @@ -0,0 +1,8 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadConverter::BinaryPlain < ::Temporalio::Converters::PayloadConverter::Encoding + ENCODING = T.let(T.unsafe(nil), String) +end diff --git a/temporalio/rbi/temporalio/converters/payload_converter/binary_protobuf.rbi b/temporalio/rbi/temporalio/converters/payload_converter/binary_protobuf.rbi new file mode 100644 index 00000000..880ef7df --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_converter/binary_protobuf.rbi @@ -0,0 +1,8 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadConverter::BinaryProtobuf < ::Temporalio::Converters::PayloadConverter::Encoding + ENCODING = T.let(T.unsafe(nil), String) +end diff --git a/temporalio/rbi/temporalio/converters/payload_converter/composite.rbi b/temporalio/rbi/temporalio/converters/payload_converter/composite.rbi new file mode 100644 index 00000000..51f9797d --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_converter/composite.rbi @@ -0,0 +1,23 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadConverter::Composite < ::Temporalio::Converters::PayloadConverter + extend T::Sig + + sig { returns(T::Hash[String, Temporalio::Converters::PayloadConverter::Encoding]) } + attr_reader :converters + + sig { params(converters: Temporalio::Converters::PayloadConverter::Encoding).void } + def initialize(*converters); end + + sig { params(value: T.nilable(Object), hint: T.nilable(Object)).returns(Temporalio::Api::Common::V1::Payload) } + def to_payload(value, hint: T.unsafe(nil)); end + + sig { params(payload: T.nilable(Temporalio::Api::Common::V1::Payload), hint: T.nilable(Object)).returns(T.nilable(Object)) } + def from_payload(payload, hint: T.unsafe(nil)); end + + class ConverterNotFound < ::Temporalio::Error; end + class EncodingNotSet < ::Temporalio::Error; end +end diff --git a/temporalio/rbi/temporalio/converters/payload_converter/encoding.rbi b/temporalio/rbi/temporalio/converters/payload_converter/encoding.rbi new file mode 100644 index 00000000..f9448386 --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_converter/encoding.rbi @@ -0,0 +1,17 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadConverter::Encoding + extend T::Sig + + sig { returns(String) } + def encoding; end + + sig { params(value: T.nilable(Object), hint: T.nilable(Object)).returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def to_payload(value, hint: T.unsafe(nil)); end + + sig { params(payload: T.nilable(Temporalio::Api::Common::V1::Payload), hint: T.nilable(Object)).returns(T.nilable(Object)) } + def from_payload(payload, hint: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/converters/payload_converter/json_plain.rbi b/temporalio/rbi/temporalio/converters/payload_converter/json_plain.rbi new file mode 100644 index 00000000..fa680061 --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_converter/json_plain.rbi @@ -0,0 +1,13 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadConverter::JSONPlain < ::Temporalio::Converters::PayloadConverter::Encoding + extend T::Sig + + ENCODING = T.let(T.unsafe(nil), String) + + sig { params(parse_options: T::Hash[Symbol, Object], generate_options: T::Hash[Symbol, Object]).void } + def initialize(parse_options: T.unsafe(nil), generate_options: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/converters/payload_converter/json_protobuf.rbi b/temporalio/rbi/temporalio/converters/payload_converter/json_protobuf.rbi new file mode 100644 index 00000000..4f38b618 --- /dev/null +++ b/temporalio/rbi/temporalio/converters/payload_converter/json_protobuf.rbi @@ -0,0 +1,8 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::PayloadConverter::JSONProtobuf < ::Temporalio::Converters::PayloadConverter::Encoding + ENCODING = T.let(T.unsafe(nil), String) +end diff --git a/temporalio/rbi/temporalio/converters/raw_value.rbi b/temporalio/rbi/temporalio/converters/raw_value.rbi new file mode 100644 index 00000000..6376219e --- /dev/null +++ b/temporalio/rbi/temporalio/converters/raw_value.rbi @@ -0,0 +1,14 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Converters::RawValue + extend T::Sig + + sig { returns(Temporalio::Api::Common::V1::Payload) } + attr_reader :payload + + sig { params(payload: Temporalio::Api::Common::V1::Payload).void } + def initialize(payload); end +end diff --git a/temporalio/rbi/temporalio/env_config.rbi b/temporalio/rbi/temporalio/env_config.rbi new file mode 100644 index 00000000..ef7bd885 --- /dev/null +++ b/temporalio/rbi/temporalio/env_config.rbi @@ -0,0 +1,159 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::EnvConfig; end + +class Temporalio::EnvConfig::ClientConfigTLS < ::Data + extend T::Sig + + sig { returns(T.nilable(T::Boolean)) } + def disabled; end + + sig { returns(T.nilable(String)) } + def server_name; end + + sig { returns(T.nilable(T.any(Pathname, String))) } + def server_root_ca_cert; end + + sig { returns(T.nilable(T.any(Pathname, String))) } + def client_cert; end + + sig { returns(T.nilable(T.any(Pathname, String))) } + def client_private_key; end + + sig do + params( + disabled: T.nilable(T::Boolean), + server_name: T.nilable(String), + server_root_ca_cert: T.nilable(T.any(Pathname, String)), + client_cert: T.nilable(T.any(Pathname, String)), + client_private_key: T.nilable(T.any(Pathname, String)) + ).void + end + def initialize( + disabled: T.unsafe(nil), + server_name: T.unsafe(nil), + server_root_ca_cert: T.unsafe(nil), + client_cert: T.unsafe(nil), + client_private_key: T.unsafe(nil) + ); end + + sig { returns(T::Hash[Symbol, Object]) } + def to_h; end + + sig { returns(T.any(Temporalio::Client::Connection::TLSOptions, FalseClass)) } + def to_client_tls_options; end + + sig { params(hash: T.nilable(T::Hash[Symbol, Object])).returns(T.nilable(Temporalio::EnvConfig::ClientConfigTLS)) } + def self.from_h(hash); end +end + +class Temporalio::EnvConfig::ClientConfigProfile < ::Data + extend T::Sig + + sig { returns(T.nilable(String)) } + def address; end + + sig { returns(T.nilable(String)) } + def namespace; end + + sig { returns(T.nilable(String)) } + def api_key; end + + sig { returns(T.nilable(Temporalio::EnvConfig::ClientConfigTLS)) } + def tls; end + + sig { returns(T::Hash[String, String]) } + def grpc_meta; end + + sig do + params( + address: T.nilable(String), + namespace: T.nilable(String), + api_key: T.nilable(String), + tls: T.nilable(Temporalio::EnvConfig::ClientConfigTLS), + grpc_meta: T::Hash[String, String] + ).void + end + def initialize( + address: T.unsafe(nil), + namespace: T.unsafe(nil), + api_key: T.unsafe(nil), + tls: T.unsafe(nil), + grpc_meta: T.unsafe(nil) + ); end + + sig { params(hash: T::Hash[Symbol, Object]).returns(Temporalio::EnvConfig::ClientConfigProfile) } + def self.from_h(hash); end + + sig do + params( + profile: T.nilable(String), + config_source: T.nilable(T.any(Pathname, String)), + disable_file: T::Boolean, + disable_env: T::Boolean, + config_file_strict: T::Boolean, + override_env_vars: T.nilable(T::Hash[String, String]) + ).returns(Temporalio::EnvConfig::ClientConfigProfile) + end + def self.load( + profile: T.unsafe(nil), + config_source: T.unsafe(nil), + disable_file: T.unsafe(nil), + disable_env: T.unsafe(nil), + config_file_strict: T.unsafe(nil), + override_env_vars: T.unsafe(nil) + ); end + + sig { returns(T::Hash[Symbol, Object]) } + def to_h; end + + sig { returns([T::Array[T.nilable(String)], T::Hash[Symbol, Object]]) } + def to_client_connect_options; end +end + +class Temporalio::EnvConfig::ClientConfig < ::Data + extend T::Sig + + sig { returns(T::Hash[String, Temporalio::EnvConfig::ClientConfigProfile]) } + def profiles; end + + sig { params(profiles: T::Hash[String, Temporalio::EnvConfig::ClientConfigProfile]).void } + def initialize(profiles: T.unsafe(nil)); end + + sig { params(hash: T::Hash[String, T::Hash[Symbol, Object]]).returns(Temporalio::EnvConfig::ClientConfig) } + def self.from_h(hash); end + + sig do + params( + config_source: T.nilable(T.any(Pathname, String)), + config_file_strict: T::Boolean, + override_env_vars: T.nilable(T::Hash[String, String]) + ).returns(Temporalio::EnvConfig::ClientConfig) + end + def self.load(config_source: T.unsafe(nil), config_file_strict: T.unsafe(nil), override_env_vars: T.unsafe(nil)); end + + sig do + params( + profile: T.nilable(String), + config_source: T.nilable(T.any(Pathname, String)), + disable_file: T::Boolean, + disable_env: T::Boolean, + config_file_strict: T::Boolean, + override_env_vars: T.nilable(T::Hash[String, String]) + ).returns([T::Array[T.nilable(String)], T::Hash[Symbol, Object]]) + end + def self.load_client_connect_options( + profile: T.unsafe(nil), + config_source: T.unsafe(nil), + disable_file: T.unsafe(nil), + disable_env: T.unsafe(nil), + config_file_strict: T.unsafe(nil), + override_env_vars: T.unsafe(nil) + ); end + + sig { override(allow_incompatible: true).returns(T::Hash[String, T::Hash[Symbol, Object]]) } + def to_h; end +end diff --git a/temporalio/rbi/temporalio/error.rbi b/temporalio/rbi/temporalio/error.rbi new file mode 100644 index 00000000..8cd8c2f4 --- /dev/null +++ b/temporalio/rbi/temporalio/error.rbi @@ -0,0 +1,316 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Error < ::StandardError + sig { params(error: Exception).returns(T::Boolean) } + def self.canceled?(error); end +end + +class Temporalio::Error::WorkflowAlreadyStartedError < ::Temporalio::Error::Failure + sig { params(workflow_id: String, workflow_type: String, run_id: T.nilable(String)).void } + def initialize(workflow_id:, workflow_type:, run_id:); end + + sig { returns(String) } + attr_reader :workflow_id + + sig { returns(String) } + attr_reader :workflow_type + + sig { returns(T.nilable(String)) } + attr_reader :run_id +end + +class Temporalio::Error::ApplicationError < ::Temporalio::Error::Failure + sig do + params( + message: String, + details: T.nilable(Object), + type: T.nilable(String), + non_retryable: T::Boolean, + next_retry_delay: T.nilable(T.any(Integer, Float)), + category: Integer + ).void + end + def initialize(message, *details, type: nil, non_retryable: false, next_retry_delay: nil, category: T.unsafe(nil)); end + + sig { returns(T::Array[T.nilable(Object)]) } + attr_reader :details + + sig { returns(T.nilable(String)) } + attr_reader :type + + sig { returns(T::Boolean) } + attr_reader :non_retryable + + sig { returns(T.nilable(T.any(Integer, Float))) } + attr_reader :next_retry_delay + + sig { returns(Integer) } + attr_reader :category + + sig { returns(T::Boolean) } + def retryable?; end +end + +module Temporalio::Error::ApplicationError::Category + UNSPECIFIED = T.let(T.unsafe(nil), Integer) + BENIGN = T.let(T.unsafe(nil), Integer) +end + +class Temporalio::Error::CanceledError < ::Temporalio::Error::Failure + sig { params(message: String, details: T::Array[T.nilable(Object)]).void } + def initialize(message, details: []); end + + sig { returns(T::Array[T.nilable(Object)]) } + attr_reader :details +end + +class Temporalio::Error::TerminatedError < ::Temporalio::Error::Failure + sig { params(message: String, details: T::Array[T.nilable(Object)]).void } + def initialize(message, details:); end + + sig { returns(T::Array[T.nilable(Object)]) } + attr_reader :details +end + +class Temporalio::Error::TimeoutError < ::Temporalio::Error::Failure + sig do + params( + message: String, + type: Integer, + last_heartbeat_details: T::Array[T.nilable(Object)] + ).void + end + def initialize(message, type:, last_heartbeat_details:); end + + sig { returns(Integer) } + attr_reader :type + + sig { returns(T::Array[T.nilable(Object)]) } + attr_reader :last_heartbeat_details +end + +module Temporalio::Error::TimeoutError::TimeoutType + START_TO_CLOSE = T.let(T.unsafe(nil), Integer) + SCHEDULE_TO_START = T.let(T.unsafe(nil), Integer) + SCHEDULE_TO_CLOSE = T.let(T.unsafe(nil), Integer) + HEARTBEAT = T.let(T.unsafe(nil), Integer) +end + +class Temporalio::Error::ServerError < ::Temporalio::Error::Failure + sig { params(message: String, non_retryable: T::Boolean).void } + def initialize(message, non_retryable:); end + + sig { returns(T::Boolean) } + attr_reader :non_retryable + + sig { returns(T::Boolean) } + def retryable?; end +end + +module Temporalio::Error::RetryState + IN_PROGRESS = T.let(T.unsafe(nil), Integer) + NON_RETRYABLE_FAILURE = T.let(T.unsafe(nil), Integer) + TIMEOUT = T.let(T.unsafe(nil), Integer) + MAXIMUM_ATTEMPTS_REACHED = T.let(T.unsafe(nil), Integer) + RETRY_POLICY_NOT_SET = T.let(T.unsafe(nil), Integer) + INTERNAL_SERVER_ERROR = T.let(T.unsafe(nil), Integer) + CANCEL_REQUESTED = T.let(T.unsafe(nil), Integer) +end + +class Temporalio::Error::ActivityError < ::Temporalio::Error::Failure + sig do + params( + message: String, + scheduled_event_id: Integer, + started_event_id: Integer, + identity: String, + activity_type: String, + activity_id: String, + retry_state: T.nilable(Integer) + ).void + end + def initialize(message, scheduled_event_id:, started_event_id:, identity:, activity_type:, activity_id:, retry_state:); end + + sig { returns(Integer) } + attr_reader :scheduled_event_id + + sig { returns(Integer) } + attr_reader :started_event_id + + sig { returns(String) } + attr_reader :identity + + sig { returns(String) } + attr_reader :activity_type + + sig { returns(String) } + attr_reader :activity_id + + sig { returns(T.nilable(Integer)) } + attr_reader :retry_state +end + +class Temporalio::Error::ChildWorkflowError < ::Temporalio::Error::Failure + sig do + params( + message: String, + namespace: String, + workflow_id: String, + run_id: String, + workflow_type: String, + initiated_event_id: Integer, + started_event_id: Integer, + retry_state: T.nilable(Integer) + ).void + end + def initialize(message, namespace:, workflow_id:, run_id:, workflow_type:, initiated_event_id:, started_event_id:, retry_state:); end + + sig { returns(String) } + attr_reader :namespace + + sig { returns(String) } + attr_reader :workflow_id + + sig { returns(String) } + attr_reader :run_id + + sig { returns(String) } + attr_reader :workflow_type + + sig { returns(Integer) } + attr_reader :initiated_event_id + + sig { returns(Integer) } + attr_reader :started_event_id + + sig { returns(T.nilable(Integer)) } + attr_reader :retry_state +end + +class Temporalio::Error::NexusOperationError < ::Temporalio::Error::Failure + sig do + params( + message: String, + endpoint: String, + service: String, + operation: String, + operation_token: T.nilable(String) + ).void + end + def initialize(message, endpoint:, service:, operation:, operation_token:); end + + sig { returns(String) } + attr_reader :endpoint + + sig { returns(String) } + attr_reader :service + + sig { returns(String) } + attr_reader :operation + + sig { returns(T.nilable(String)) } + attr_reader :operation_token +end + +class Temporalio::Error::NexusHandlerError < ::Temporalio::Error::Failure + sig do + params( + message: String, + error_type: T.any(Symbol, String), + retry_behavior: Integer + ).void + end + def initialize(message, error_type:, retry_behavior:); end + + sig { returns(Symbol) } + attr_reader :error_type + + sig { returns(Integer) } + attr_reader :retry_behavior +end + +module Temporalio::Error::NexusHandlerError::RetryBehavior + UNSPECIFIED = T.let(T.unsafe(nil), Integer) + RETRYABLE = T.let(T.unsafe(nil), Integer) + NON_RETRYABLE = T.let(T.unsafe(nil), Integer) +end + +class Temporalio::Error::AsyncActivityCanceledError < ::Temporalio::Error + sig { params(details: Temporalio::Activity::CancellationDetails).void } + def initialize(details); end + + sig { returns(Temporalio::Activity::CancellationDetails) } + attr_reader :details +end + +class Temporalio::Error::WorkflowFailedError < ::Temporalio::Error + sig { params(message: T.nilable(String)).void } + def initialize(message = nil); end +end + +class Temporalio::Error::WorkflowContinuedAsNewError < ::Temporalio::Error + sig { params(new_run_id: String).void } + def initialize(new_run_id:); end + + sig { returns(String) } + attr_reader :new_run_id +end + +class Temporalio::Error::WorkflowQueryFailedError < ::Temporalio::Error; end + +class Temporalio::Error::WorkflowQueryRejectedError < ::Temporalio::Error + sig { params(status: Integer).void } + def initialize(status:); end + + sig { returns(Integer) } + attr_reader :status +end + +class Temporalio::Error::WorkflowUpdateFailedError < ::Temporalio::Error + sig { void } + def initialize; end +end + +class Temporalio::Error::WorkflowUpdateRPCTimeoutOrCanceledError < ::Temporalio::Error + sig { void } + def initialize; end +end + +class Temporalio::Error::ScheduleAlreadyRunningError < ::Temporalio::Error + sig { void } + def initialize; end +end + +class Temporalio::Error::RPCError < ::Temporalio::Error + sig { params(message: String, code: Integer, raw_grpc_status: T.nilable(Object)).void } + def initialize(message, code:, raw_grpc_status:); end + + sig { returns(Integer) } + attr_reader :code + + sig { returns(Temporalio::Api::Common::V1::GrpcStatus) } + def grpc_status; end +end + +module Temporalio::Error::RPCError::Code + OK = T.let(T.unsafe(nil), Integer) + CANCELED = T.let(T.unsafe(nil), Integer) + UNKNOWN = T.let(T.unsafe(nil), Integer) + INVALID_ARGUMENT = T.let(T.unsafe(nil), Integer) + DEADLINE_EXCEEDED = T.let(T.unsafe(nil), Integer) + NOT_FOUND = T.let(T.unsafe(nil), Integer) + ALREADY_EXISTS = T.let(T.unsafe(nil), Integer) + PERMISSION_DENIED = T.let(T.unsafe(nil), Integer) + RESOURCE_EXHAUSTED = T.let(T.unsafe(nil), Integer) + FAILED_PRECONDITION = T.let(T.unsafe(nil), Integer) + ABORTED = T.let(T.unsafe(nil), Integer) + OUT_OF_RANGE = T.let(T.unsafe(nil), Integer) + UNIMPLEMENTED = T.let(T.unsafe(nil), Integer) + INTERNAL = T.let(T.unsafe(nil), Integer) + UNAVAILABLE = T.let(T.unsafe(nil), Integer) + DATA_LOSS = T.let(T.unsafe(nil), Integer) + UNAUTHENTICATED = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/error/failure.rbi b/temporalio/rbi/temporalio/error/failure.rbi new file mode 100644 index 00000000..48f3fc5a --- /dev/null +++ b/temporalio/rbi/temporalio/error/failure.rbi @@ -0,0 +1,6 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Error::Failure < ::Temporalio::Error; end diff --git a/temporalio/rbi/temporalio/internal.rbi b/temporalio/rbi/temporalio/internal.rbi new file mode 100644 index 00000000..6c0a5684 --- /dev/null +++ b/temporalio/rbi/temporalio/internal.rbi @@ -0,0 +1,3 @@ +# typed: true + +module Temporalio::Internal; end diff --git a/temporalio/rbi/temporalio/internal/bridge.rbi b/temporalio/rbi/temporalio/internal/bridge.rbi new file mode 100644 index 00000000..97905db9 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge.rbi @@ -0,0 +1,42 @@ +# typed: true + +module Temporalio::Internal::Bridge + extend T::Sig + + sig { void } + def self.assert_fiber_compatibility!; end + + sig { returns(T::Boolean) } + def self.fibers_supported; end +end + +module Temporalio::Internal::Bridge::EnvConfig + extend T::Sig + + sig do + params( + profile: T.nilable(String), + path: T.nilable(String), + data: T.nilable(String), + disable_file: T::Boolean, + disable_env: T::Boolean, + config_file_strict: T::Boolean, + override_env_vars: T.nilable(T::Hash[String, String]) + ).returns(T::Hash[Symbol, T.nilable(Object)]) + end + def self.load_client_connect_config(profile, path, data, disable_file, disable_env, config_file_strict, + override_env_vars); end + + sig do + params( + path: T.nilable(String), + data: T.nilable(String), + config_file_strict: T::Boolean, + override_env_vars: T.nilable(T::Hash[String, String]) + ).returns(T::Hash[String, T::Hash[Symbol, T.nilable(Object)]]) + end + def self.load_client_config(path, data, config_file_strict, override_env_vars); end +end + +class Temporalio::Internal::Bridge::Error < StandardError +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api.rbi b/temporalio/rbi/temporalio/internal/bridge/api.rbi new file mode 100644 index 00000000..64f55041 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api.rbi @@ -0,0 +1,3 @@ +# typed: true + +module Temporalio::Internal::Bridge::Api; end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/activity_result/activity_result.rbi b/temporalio/rbi/temporalio/internal/bridge/api/activity_result/activity_result.rbi new file mode 100644 index 00000000..e1a1549a --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/activity_result/activity_result.rbi @@ -0,0 +1,547 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/activity_result/activity_result.proto +# typed: strict + +# Used to report activity completions to core +class Temporalio::Internal::Bridge::Api::ActivityResult::ActivityExecutionResult + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + completed: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Success), + failed: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Failure), + cancelled: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation), + will_complete_async: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::WillCompleteAsync) + ).void + end + def initialize( + completed: nil, + failed: nil, + cancelled: nil, + will_complete_async: nil + ) + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Success)) } + def completed + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Success)).void } + def completed=(value) + end + + sig { void } + def clear_completed + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Failure)) } + def failed + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Failure)).void } + def failed=(value) + end + + sig { void } + def clear_failed + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation)) } + def cancelled + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation)).void } + def cancelled=(value) + end + + sig { void } + def clear_cancelled + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::WillCompleteAsync)) } + def will_complete_async + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::WillCompleteAsync)).void } + def will_complete_async=(value) + end + + sig { void } + def clear_will_complete_async + end + + sig { returns(T.nilable(Symbol)) } + def status + 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::Internal::Bridge::Api::ActivityResult::ActivityExecutionResult) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::ActivityExecutionResult).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityResult::ActivityExecutionResult) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::ActivityExecutionResult, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used to report activity resolutions to lang. IE: This is what the activities are resolved with +# in the workflow. +class Temporalio::Internal::Bridge::Api::ActivityResult::ActivityResolution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + completed: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Success), + failed: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Failure), + cancelled: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation), + backoff: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::DoBackoff) + ).void + end + def initialize( + completed: nil, + failed: nil, + cancelled: nil, + backoff: nil + ) + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Success)) } + def completed + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Success)).void } + def completed=(value) + end + + sig { void } + def clear_completed + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Failure)) } + def failed + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Failure)).void } + def failed=(value) + end + + sig { void } + def clear_failed + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation)) } + def cancelled + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation)).void } + def cancelled=(value) + end + + sig { void } + def clear_cancelled + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::DoBackoff)) } + def backoff + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::DoBackoff)).void } + def backoff=(value) + end + + sig { void } + def clear_backoff + end + + sig { returns(T.nilable(Symbol)) } + def status + 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::Internal::Bridge::Api::ActivityResult::ActivityResolution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::ActivityResolution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityResult::ActivityResolution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::ActivityResolution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used to report successful completion either when executing or resolving +class Temporalio::Internal::Bridge::Api::ActivityResult::Success + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result: T.nilable(Temporalio::Api::Common::V1::Payload) + ).void + end + def initialize( + result: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def result=(value) + end + + sig { void } + def clear_result + 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::Internal::Bridge::Api::ActivityResult::Success) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::Success).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityResult::Success) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::Success, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used to report activity failure either when executing or resolving +class Temporalio::Internal::Bridge::Api::ActivityResult::Failure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Internal::Bridge::Api::ActivityResult::Failure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::Failure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityResult::Failure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::Failure, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used to report cancellation from both Core and Lang. +# When Lang reports a cancelled activity, it must put a CancelledFailure in the failure field. +# When Core reports a cancelled activity, it must put an ActivityFailure with CancelledFailure +# as the cause in the failure field. +class Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Internal::Bridge::Api::ActivityResult::Cancellation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::Cancellation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used in ActivityExecutionResult to notify Core that this Activity will complete asynchronously. +# Core will forget about this Activity and free up resources used to track this Activity. +class Temporalio::Internal::Bridge::Api::ActivityResult::WillCompleteAsync + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Internal::Bridge::Api::ActivityResult::WillCompleteAsync) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::WillCompleteAsync).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityResult::WillCompleteAsync) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::WillCompleteAsync, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Issued when a local activity needs to retry but also wants to back off more than would be +# reasonable to WFT heartbeat for. Lang is expected to schedule a timer for the duration +# and then start a local activity of the same type & same inputs with the provided attempt number +# after the timer has elapsed. +# +# This exists because Core does not have a concept of starting commands by itself, they originate +# from lang. So expecting lang to start the timer / next pass of the activity fits more smoothly. +class Temporalio::Internal::Bridge::Api::ActivityResult::DoBackoff + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + attempt: T.nilable(Integer), + backoff_duration: T.nilable(Google::Protobuf::Duration), + original_schedule_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + attempt: 0, + backoff_duration: nil, + original_schedule_time: nil + ) + end + + # The attempt number that lang should provide when scheduling the retry. If the LA failed +# on attempt 4 and we told lang to back off with a timer, this number will be 5. + sig { returns(Integer) } + def attempt + end + + # The attempt number that lang should provide when scheduling the retry. If the LA failed +# on attempt 4 and we told lang to back off with a timer, this number will be 5. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The attempt number that lang should provide when scheduling the retry. If the LA failed +# on attempt 4 and we told lang to back off with a timer, this number will be 5. + sig { void } + def clear_attempt + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def backoff_duration + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def backoff_duration=(value) + end + + sig { void } + def clear_backoff_duration + end + + # The time the first attempt of this local activity was scheduled. Must be passed with attempt +# to the retry LA. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def original_schedule_time + end + + # The time the first attempt of this local activity was scheduled. Must be passed with attempt +# to the retry LA. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def original_schedule_time=(value) + end + + # The time the first attempt of this local activity was scheduled. Must be passed with attempt +# to the retry LA. + sig { void } + def clear_original_schedule_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::Internal::Bridge::Api::ActivityResult::DoBackoff) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::DoBackoff).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityResult::DoBackoff) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityResult::DoBackoff, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/activity_task/activity_task.rbi b/temporalio/rbi/temporalio/internal/bridge/api/activity_task/activity_task.rbi new file mode 100644 index 00000000..67b72307 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/activity_task/activity_task.rbi @@ -0,0 +1,705 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/activity_task/activity_task.proto +# typed: strict + +class Temporalio::Internal::Bridge::Api::ActivityTask::ActivityTask + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + start: T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::Start), + cancel: T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::Cancel) + ).void + end + def initialize( + task_token: "", + start: nil, + cancel: nil + ) + end + + # A unique identifier for this task + sig { returns(String) } + def task_token + end + + # A unique identifier for this task + sig { params(value: String).void } + def task_token=(value) + end + + # A unique identifier for this task + sig { void } + def clear_task_token + end + + # Start activity execution. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::Start)) } + def start + end + + # Start activity execution. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::Start)).void } + def start=(value) + end + + # Start activity execution. + sig { void } + def clear_start + end + + # Attempt to cancel activity execution. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::Cancel)) } + def cancel + end + + # Attempt to cancel activity execution. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::Cancel)).void } + def cancel=(value) + end + + # Attempt to cancel activity execution. + sig { void } + def clear_cancel + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Internal::Bridge::Api::ActivityTask::ActivityTask) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::ActivityTask).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityTask::ActivityTask) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::ActivityTask, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Begin executing an activity +class Temporalio::Internal::Bridge::Api::ActivityTask::Start + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_namespace: T.nilable(String), + workflow_type: T.nilable(String), + workflow_execution: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + activity_id: T.nilable(String), + activity_type: T.nilable(String), + header_fields: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + input: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + heartbeat_details: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + scheduled_time: T.nilable(Google::Protobuf::Timestamp), + current_attempt_scheduled_time: T.nilable(Google::Protobuf::Timestamp), + started_time: T.nilable(Google::Protobuf::Timestamp), + attempt: T.nilable(Integer), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + heartbeat_timeout: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + priority: T.nilable(Temporalio::Api::Common::V1::Priority), + is_local: T.nilable(T::Boolean), + run_id: T.nilable(String) + ).void + end + def initialize( + workflow_namespace: "", + workflow_type: "", + workflow_execution: nil, + activity_id: "", + activity_type: "", + header_fields: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + input: [], + heartbeat_details: [], + scheduled_time: nil, + current_attempt_scheduled_time: nil, + started_time: nil, + attempt: 0, + schedule_to_close_timeout: nil, + start_to_close_timeout: nil, + heartbeat_timeout: nil, + retry_policy: nil, + priority: nil, + is_local: false, + run_id: "" + ) + end + + # The namespace the workflow lives in + sig { returns(String) } + def workflow_namespace + end + + # The namespace the workflow lives in + sig { params(value: String).void } + def workflow_namespace=(value) + end + + # The namespace the workflow lives in + sig { void } + def clear_workflow_namespace + end + + # The workflow's type name or function identifier + sig { returns(String) } + def workflow_type + end + + # The workflow's type name or function identifier + sig { params(value: String).void } + def workflow_type=(value) + end + + # The workflow's type name or function identifier + sig { void } + def clear_workflow_type + end + + # The workflow execution which requested this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def workflow_execution + end + + # The workflow execution which requested this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def workflow_execution=(value) + end + + # The workflow execution which requested this activity + sig { void } + def clear_workflow_execution + end + + # The activity's ID + sig { returns(String) } + def activity_id + end + + # The activity's ID + sig { params(value: String).void } + def activity_id=(value) + end + + # The activity's ID + sig { void } + def clear_activity_id + end + + # The activity's type name or function identifier + sig { returns(String) } + def activity_type + end + + # The activity's type name or function identifier + sig { params(value: String).void } + def activity_type=(value) + end + + # The activity's type name or function identifier + sig { void } + def clear_activity_type + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def header_fields + end + + sig { params(value: ::Google::Protobuf::Map).void } + def header_fields=(value) + end + + sig { void } + def clear_header_fields + end + + # Arguments to the activity + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def input + end + + # Arguments to the activity + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def input=(value) + end + + # Arguments to the activity + sig { void } + def clear_input + end + + # The last details that were recorded by a heartbeat when this task was generated + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def heartbeat_details + end + + # The last details that were recorded by a heartbeat when this task was generated + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def heartbeat_details=(value) + end + + # The last details that were recorded by a heartbeat when this task was generated + sig { void } + def clear_heartbeat_details + end + + # When the task was *first* scheduled + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def scheduled_time + end + + # When the task was *first* scheduled + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def scheduled_time=(value) + end + + # When the task was *first* scheduled + sig { void } + def clear_scheduled_time + end + + # When this current attempt at the task was scheduled + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def current_attempt_scheduled_time + end + + # When this current attempt at the task was scheduled + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def current_attempt_scheduled_time=(value) + end + + # When this current attempt at the task was scheduled + sig { void } + def clear_current_attempt_scheduled_time + end + + # When this attempt was started, which is to say when core received it by polling. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def started_time + end + + # When this attempt was started, which is to say when core received it by polling. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def started_time=(value) + end + + # When this attempt was started, which is to say when core received it by polling. + sig { void } + def clear_started_time + end + + sig { returns(Integer) } + def attempt + end + + sig { params(value: Integer).void } + def attempt=(value) + end + + sig { void } + def clear_attempt + end + + # Timeout from the first schedule time to completion + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_close_timeout + end + + # Timeout from the first schedule time to completion + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_close_timeout=(value) + end + + # Timeout from the first schedule time to completion + sig { void } + def clear_schedule_to_close_timeout + end + + # Timeout from starting an attempt to reporting its result + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Timeout from starting an attempt to reporting its result + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def start_to_close_timeout=(value) + end + + # Timeout from starting an attempt to reporting its result + sig { void } + def clear_start_to_close_timeout + end + + # If set a heartbeat must be reported within this interval + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def heartbeat_timeout + end + + # If set a heartbeat must be reported within this interval + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def heartbeat_timeout=(value) + end + + # If set a heartbeat must be reported within this interval + sig { void } + def clear_heartbeat_timeout + end + + # This is an actual retry policy the service uses. It can be different from the one provided +# (or not) during activity scheduling as the service can override the provided one in case its +# values are not specified or exceed configured system limits. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # This is an actual retry policy the service uses. It can be different from the one provided +# (or not) during activity scheduling as the service can override the provided one in case its +# values are not specified or exceed configured system limits. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # This is an actual retry policy the service uses. It can be different from the one provided +# (or not) during activity scheduling as the service can override the provided one in case its +# values are not specified or exceed configured system limits. + sig { void } + def clear_retry_policy + end + + # Priority of this activity. Local activities will always have this field set to the default. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority of this activity. Local activities will always have this field set to the default. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority of this activity. Local activities will always have this field set to the default. + sig { void } + def clear_priority + end + + # Set to true if this is a local activity. Note that heartbeating does not apply to local +# activities. + sig { returns(T::Boolean) } + def is_local + end + + # Set to true if this is a local activity. Note that heartbeating does not apply to local +# activities. + sig { params(value: T::Boolean).void } + def is_local=(value) + end + + # Set to true if this is a local activity. Note that heartbeating does not apply to local +# activities. + sig { void } + def clear_is_local + end + + # Run ID of this activity execution. Only set for standalone activities. + sig { returns(String) } + def run_id + end + + # Run ID of this activity execution. Only set for standalone activities. + sig { params(value: String).void } + def run_id=(value) + end + + # Run ID of this activity execution. Only set for standalone activities. + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Internal::Bridge::Api::ActivityTask::Start) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::Start).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityTask::Start) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::Start, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Attempt to cancel a running activity +class Temporalio::Internal::Bridge::Api::ActivityTask::Cancel + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + reason: T.nilable(T.any(Symbol, String, Integer)), + details: T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::ActivityCancellationDetails) + ).void + end + def initialize( + reason: :NOT_FOUND, + details: nil + ) + end + + # Primary cancellation reason + sig { returns(T.any(Symbol, Integer)) } + def reason + end + + # Primary cancellation reason + sig { params(value: T.any(Symbol, String, Integer)).void } + def reason=(value) + end + + # Primary cancellation reason + sig { void } + def clear_reason + end + + # Activity cancellation details, surfaces all cancellation reasons. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::ActivityCancellationDetails)) } + def details + end + + # Activity cancellation details, surfaces all cancellation reasons. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityTask::ActivityCancellationDetails)).void } + def details=(value) + end + + # Activity cancellation details, surfaces all cancellation reasons. + sig { void } + def clear_details + 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::Internal::Bridge::Api::ActivityTask::Cancel) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::Cancel).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityTask::Cancel) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::Cancel, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::ActivityTask::ActivityCancellationDetails + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + is_not_found: T.nilable(T::Boolean), + is_cancelled: T.nilable(T::Boolean), + is_paused: T.nilable(T::Boolean), + is_timed_out: T.nilable(T::Boolean), + is_worker_shutdown: T.nilable(T::Boolean), + is_reset: T.nilable(T::Boolean) + ).void + end + def initialize( + is_not_found: false, + is_cancelled: false, + is_paused: false, + is_timed_out: false, + is_worker_shutdown: false, + is_reset: false + ) + end + + sig { returns(T::Boolean) } + def is_not_found + end + + sig { params(value: T::Boolean).void } + def is_not_found=(value) + end + + sig { void } + def clear_is_not_found + end + + sig { returns(T::Boolean) } + def is_cancelled + end + + sig { params(value: T::Boolean).void } + def is_cancelled=(value) + end + + sig { void } + def clear_is_cancelled + end + + sig { returns(T::Boolean) } + def is_paused + end + + sig { params(value: T::Boolean).void } + def is_paused=(value) + end + + sig { void } + def clear_is_paused + end + + sig { returns(T::Boolean) } + def is_timed_out + end + + sig { params(value: T::Boolean).void } + def is_timed_out=(value) + end + + sig { void } + def clear_is_timed_out + end + + sig { returns(T::Boolean) } + def is_worker_shutdown + end + + sig { params(value: T::Boolean).void } + def is_worker_shutdown=(value) + end + + sig { void } + def clear_is_worker_shutdown + end + + sig { returns(T::Boolean) } + def is_reset + end + + sig { params(value: T::Boolean).void } + def is_reset=(value) + end + + sig { void } + def clear_is_reset + 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::Internal::Bridge::Api::ActivityTask::ActivityCancellationDetails) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::ActivityCancellationDetails).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ActivityTask::ActivityCancellationDetails) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ActivityTask::ActivityCancellationDetails, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::ActivityTask::ActivityCancelReason + self::NOT_FOUND = T.let(0, Integer) + self::CANCELLED = T.let(1, Integer) + self::TIMED_OUT = T.let(2, Integer) + self::WORKER_SHUTDOWN = T.let(3, Integer) + self::PAUSED = T.let(4, Integer) + self::RESET = T.let(5, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/child_workflow/child_workflow.rbi b/temporalio/rbi/temporalio/internal/bridge/api/child_workflow/child_workflow.rbi new file mode 100644 index 00000000..e9167cac --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/child_workflow/child_workflow.rbi @@ -0,0 +1,332 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/child_workflow/child_workflow.proto +# typed: strict + +# Used by core to resolve child workflow executions. +class Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + completed: T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Success), + failed: T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Failure), + cancelled: T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Cancellation) + ).void + end + def initialize( + completed: nil, + failed: nil, + cancelled: nil + ) + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Success)) } + def completed + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Success)).void } + def completed=(value) + end + + sig { void } + def clear_completed + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Failure)) } + def failed + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Failure)).void } + def failed=(value) + end + + sig { void } + def clear_failed + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Cancellation)) } + def cancelled + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::Cancellation)).void } + def cancelled=(value) + end + + sig { void } + def clear_cancelled + end + + sig { returns(T.nilable(Symbol)) } + def status + 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::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used in ChildWorkflowResult to report successful completion. +class Temporalio::Internal::Bridge::Api::ChildWorkflow::Success + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result: T.nilable(Temporalio::Api::Common::V1::Payload) + ).void + end + def initialize( + result: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def result=(value) + end + + sig { void } + def clear_result + 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::Internal::Bridge::Api::ChildWorkflow::Success) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ChildWorkflow::Success).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ChildWorkflow::Success) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ChildWorkflow::Success, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used in ChildWorkflowResult to report non successful outcomes such as +# application failures, timeouts, terminations, and cancellations. +class Temporalio::Internal::Bridge::Api::ChildWorkflow::Failure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Internal::Bridge::Api::ChildWorkflow::Failure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ChildWorkflow::Failure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ChildWorkflow::Failure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ChildWorkflow::Failure, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Used in ChildWorkflowResult to report cancellation. +# Failure should be ChildWorkflowFailure with a CanceledFailure cause. +class Temporalio::Internal::Bridge::Api::ChildWorkflow::Cancellation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Internal::Bridge::Api::ChildWorkflow::Cancellation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ChildWorkflow::Cancellation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ChildWorkflow::Cancellation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ChildWorkflow::Cancellation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::ChildWorkflow::ParentClosePolicy + self::PARENT_CLOSE_POLICY_UNSPECIFIED = T.let(0, Integer) + self::PARENT_CLOSE_POLICY_TERMINATE = T.let(1, Integer) + self::PARENT_CLOSE_POLICY_ABANDON = T.let(2, Integer) + self::PARENT_CLOSE_POLICY_REQUEST_CANCEL = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::ChildWorkflow::StartChildWorkflowExecutionFailedCause + self::START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED = T.let(0, Integer) + self::START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_EXISTS = T.let(1, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowCancellationType + self::ABANDON = T.let(0, Integer) + self::TRY_CANCEL = T.let(1, Integer) + self::WAIT_CANCELLATION_COMPLETED = T.let(2, Integer) + self::WAIT_CANCELLATION_REQUESTED = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/common/common.rbi b/temporalio/rbi/temporalio/internal/bridge/api/common/common.rbi new file mode 100644 index 00000000..7a8f35f1 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/common/common.rbi @@ -0,0 +1,191 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/common/common.proto +# typed: strict + +# Identifying information about a particular workflow execution, including namespace +class Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + namespace: T.nilable(String), + workflow_id: T.nilable(String), + run_id: T.nilable(String) + ).void + end + def initialize( + namespace: "", + workflow_id: "", + run_id: "" + ) + end + + # Namespace the workflow run is located in + sig { returns(String) } + def namespace + end + + # Namespace the workflow run is located in + sig { params(value: String).void } + def namespace=(value) + end + + # Namespace the workflow run is located in + sig { void } + def clear_namespace + end + + # Can never be empty + sig { returns(String) } + def workflow_id + end + + # Can never be empty + sig { params(value: String).void } + def workflow_id=(value) + end + + # Can never be empty + sig { void } + def clear_workflow_id + end + + # May be empty if the most recent run of the workflow with the given ID is being targeted + sig { returns(String) } + def run_id + end + + # May be empty if the most recent run of the workflow with the given ID is being targeted + sig { params(value: String).void } + def run_id=(value) + end + + # May be empty if the most recent run of the workflow with the given ID is being targeted + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::Common::WorkerDeploymentVersion + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + deployment_name: T.nilable(String), + build_id: T.nilable(String) + ).void + end + def initialize( + deployment_name: "", + build_id: "" + ) + end + + sig { returns(String) } + def deployment_name + end + + sig { params(value: String).void } + def deployment_name=(value) + end + + sig { void } + def clear_deployment_name + end + + sig { returns(String) } + def build_id + end + + sig { params(value: String).void } + def build_id=(value) + end + + sig { void } + def clear_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::Internal::Bridge::Api::Common::WorkerDeploymentVersion) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Common::WorkerDeploymentVersion).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::Common::WorkerDeploymentVersion) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Common::WorkerDeploymentVersion, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::Common::VersioningIntent + self::UNSPECIFIED = T.let(0, Integer) + self::COMPATIBLE = T.let(1, Integer) + self::DEFAULT = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/core_interface.rbi b/temporalio/rbi/temporalio/internal/bridge/api/core_interface.rbi new file mode 100644 index 00000000..f0bba65a --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/core_interface.rbi @@ -0,0 +1,567 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/core_interface.proto +# typed: strict + +# A request as given to `record_activity_heartbeat` +class Temporalio::Internal::Bridge::Api::CoreInterface::ActivityHeartbeat + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + details: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + task_token: "", + details: [] + ) + end + + sig { returns(String) } + def task_token + end + + sig { params(value: String).void } + def task_token=(value) + end + + sig { void } + def clear_task_token + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def details + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def details=(value) + end + + sig { void } + def clear_details + 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::Internal::Bridge::Api::CoreInterface::ActivityHeartbeat) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::ActivityHeartbeat).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::CoreInterface::ActivityHeartbeat) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::ActivityHeartbeat, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A request as given to `complete_activity_task` +class Temporalio::Internal::Bridge::Api::CoreInterface::ActivityTaskCompletion + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + result: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::ActivityExecutionResult) + ).void + end + def initialize( + task_token: "", + result: nil + ) + end + + sig { returns(String) } + def task_token + end + + sig { params(value: String).void } + def task_token=(value) + end + + sig { void } + def clear_task_token + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::ActivityExecutionResult)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::ActivityExecutionResult)).void } + def result=(value) + end + + sig { void } + def clear_result + 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::Internal::Bridge::Api::CoreInterface::ActivityTaskCompletion) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::ActivityTaskCompletion).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::CoreInterface::ActivityTaskCompletion) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::ActivityTaskCompletion, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Info about workflow task slot usage +class Temporalio::Internal::Bridge::Api::CoreInterface::WorkflowSlotInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_type: T.nilable(String), + is_sticky: T.nilable(T::Boolean) + ).void + end + def initialize( + workflow_type: "", + is_sticky: false + ) + end + + sig { returns(String) } + def workflow_type + end + + sig { params(value: String).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T::Boolean) } + def is_sticky + end + + sig { params(value: T::Boolean).void } + def is_sticky=(value) + end + + sig { void } + def clear_is_sticky + 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::Internal::Bridge::Api::CoreInterface::WorkflowSlotInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::WorkflowSlotInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::CoreInterface::WorkflowSlotInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::WorkflowSlotInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Info about activity task slot usage +class Temporalio::Internal::Bridge::Api::CoreInterface::ActivitySlotInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_type: T.nilable(String) + ).void + end + def initialize( + activity_type: "" + ) + end + + sig { returns(String) } + def activity_type + end + + sig { params(value: String).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + 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::Internal::Bridge::Api::CoreInterface::ActivitySlotInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::ActivitySlotInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::CoreInterface::ActivitySlotInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::ActivitySlotInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Info about local activity slot usage +class Temporalio::Internal::Bridge::Api::CoreInterface::LocalActivitySlotInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + activity_type: T.nilable(String) + ).void + end + def initialize( + activity_type: "" + ) + end + + sig { returns(String) } + def activity_type + end + + sig { params(value: String).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + 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::Internal::Bridge::Api::CoreInterface::LocalActivitySlotInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::LocalActivitySlotInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::CoreInterface::LocalActivitySlotInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::LocalActivitySlotInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Info about nexus task slot usage +class Temporalio::Internal::Bridge::Api::CoreInterface::NexusSlotInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + service: T.nilable(String), + operation: T.nilable(String) + ).void + end + def initialize( + service: "", + operation: "" + ) + end + + sig { returns(String) } + def service + end + + sig { params(value: String).void } + def service=(value) + end + + sig { void } + def clear_service + end + + sig { returns(String) } + def operation + end + + sig { params(value: String).void } + def operation=(value) + end + + sig { void } + def clear_operation + 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::Internal::Bridge::Api::CoreInterface::NexusSlotInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::NexusSlotInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::CoreInterface::NexusSlotInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::NexusSlotInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Info about a namespace +class Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + limits: T.nilable(Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo::Limits) + ).void + end + def initialize( + limits: nil + ) + end + + # Namespace configured limits + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo::Limits)) } + def limits + end + + # Namespace configured limits + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo::Limits)).void } + def limits=(value) + end + + # Namespace configured limits + sig { void } + def clear_limits + 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::Internal::Bridge::Api::CoreInterface::NamespaceInfo) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo::Limits + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + blob_size_limit_error: T.nilable(Integer), + memo_size_limit_error: T.nilable(Integer) + ).void + end + def initialize( + blob_size_limit_error: 0, + memo_size_limit_error: 0 + ) + end + + # Maximum size in bytes for payload fields in workflow history events +# (e.g., workflow/activity inputs and results, failure details, signal payloads). +# When exceeded, the server will reject the operation with an error. + sig { returns(Integer) } + def blob_size_limit_error + end + + # Maximum size in bytes for payload fields in workflow history events +# (e.g., workflow/activity inputs and results, failure details, signal payloads). +# When exceeded, the server will reject the operation with an error. + sig { params(value: Integer).void } + def blob_size_limit_error=(value) + end + + # Maximum size in bytes for payload fields in workflow history events +# (e.g., workflow/activity inputs and results, failure details, signal payloads). +# When exceeded, the server will reject the operation with an error. + sig { void } + def clear_blob_size_limit_error + end + + # Maximum total memo size in bytes per workflow execution. + sig { returns(Integer) } + def memo_size_limit_error + end + + # Maximum total memo size in bytes per workflow execution. + sig { params(value: Integer).void } + def memo_size_limit_error=(value) + end + + # Maximum total memo size in bytes per workflow execution. + sig { void } + def clear_memo_size_limit_error + 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::Internal::Bridge::Api::CoreInterface::NamespaceInfo::Limits) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo::Limits).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo::Limits) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::CoreInterface::NamespaceInfo::Limits, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/external_data/external_data.rbi b/temporalio/rbi/temporalio/internal/bridge/api/external_data/external_data.rbi new file mode 100644 index 00000000..43e3bf66 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/external_data/external_data.rbi @@ -0,0 +1,255 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/external_data/external_data.proto +# typed: strict + +class Temporalio::Internal::Bridge::Api::ExternalData::LocalActivityMarkerData + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + attempt: T.nilable(Integer), + activity_id: T.nilable(String), + activity_type: T.nilable(String), + complete_time: T.nilable(Google::Protobuf::Timestamp), + backoff: T.nilable(Google::Protobuf::Duration), + original_schedule_time: T.nilable(Google::Protobuf::Timestamp) + ).void + end + def initialize( + seq: 0, + attempt: 0, + activity_id: "", + activity_type: "", + complete_time: nil, + backoff: nil, + original_schedule_time: nil + ) + end + + sig { returns(Integer) } + def seq + end + + sig { params(value: Integer).void } + def seq=(value) + end + + sig { void } + def clear_seq + end + + # The number of attempts at execution before we recorded this result. Typically starts at 1, +# but it is possible to start at a higher number when backing off using a timer. + sig { returns(Integer) } + def attempt + end + + # The number of attempts at execution before we recorded this result. Typically starts at 1, +# but it is possible to start at a higher number when backing off using a timer. + sig { params(value: Integer).void } + def attempt=(value) + end + + # The number of attempts at execution before we recorded this result. Typically starts at 1, +# but it is possible to start at a higher number when backing off using a timer. + sig { void } + def clear_attempt + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + sig { returns(String) } + def activity_type + end + + sig { params(value: String).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + end + + # You can think of this as "perceived completion time". It is the time the local activity thought +# it was when it completed. Which could be different from wall-clock time because of workflow +# replay. It's the WFT start time + the LA's runtime + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def complete_time + end + + # You can think of this as "perceived completion time". It is the time the local activity thought +# it was when it completed. Which could be different from wall-clock time because of workflow +# replay. It's the WFT start time + the LA's runtime + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def complete_time=(value) + end + + # You can think of this as "perceived completion time". It is the time the local activity thought +# it was when it completed. Which could be different from wall-clock time because of workflow +# replay. It's the WFT start time + the LA's runtime + sig { void } + def clear_complete_time + end + + # If set, this local activity conceptually is retrying after the specified backoff. +# Implementation wise, they are really two different LA machines, but with the same type & input. +# The retry starts with an attempt number > 1. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def backoff + end + + # If set, this local activity conceptually is retrying after the specified backoff. +# Implementation wise, they are really two different LA machines, but with the same type & input. +# The retry starts with an attempt number > 1. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def backoff=(value) + end + + # If set, this local activity conceptually is retrying after the specified backoff. +# Implementation wise, they are really two different LA machines, but with the same type & input. +# The retry starts with an attempt number > 1. + sig { void } + def clear_backoff + end + + # The time the LA was originally scheduled (wall clock time). This is used to track +# schedule-to-close timeouts when timer-based backoffs are used + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def original_schedule_time + end + + # The time the LA was originally scheduled (wall clock time). This is used to track +# schedule-to-close timeouts when timer-based backoffs are used + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def original_schedule_time=(value) + end + + # The time the LA was originally scheduled (wall clock time). This is used to track +# schedule-to-close timeouts when timer-based backoffs are used + sig { void } + def clear_original_schedule_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::Internal::Bridge::Api::ExternalData::LocalActivityMarkerData) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ExternalData::LocalActivityMarkerData).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ExternalData::LocalActivityMarkerData) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ExternalData::LocalActivityMarkerData, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::ExternalData::PatchedMarkerData + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + deprecated: T.nilable(T::Boolean) + ).void + end + def initialize( + id: "", + deprecated: false + ) + end + + # The patch id + sig { returns(String) } + def id + end + + # The patch id + sig { params(value: String).void } + def id=(value) + end + + # The patch id + sig { void } + def clear_id + end + + # Whether or not the patch is marked deprecated. + sig { returns(T::Boolean) } + def deprecated + end + + # Whether or not the patch is marked deprecated. + sig { params(value: T::Boolean).void } + def deprecated=(value) + end + + # Whether or not the patch is marked deprecated. + sig { void } + def clear_deprecated + 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::Internal::Bridge::Api::ExternalData::PatchedMarkerData) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ExternalData::PatchedMarkerData).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::ExternalData::PatchedMarkerData) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::ExternalData::PatchedMarkerData, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/nexus/nexus.rbi b/temporalio/rbi/temporalio/internal/bridge/api/nexus/nexus.rbi new file mode 100644 index 00000000..377fc89d --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/nexus/nexus.rbi @@ -0,0 +1,527 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/nexus/nexus.proto +# typed: strict + +# Used by core to resolve nexus operations. +class Temporalio::Internal::Bridge::Api::Nexus::NexusOperationResult + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + completed: T.nilable(Temporalio::Api::Common::V1::Payload), + failed: T.nilable(Temporalio::Api::Failure::V1::Failure), + cancelled: T.nilable(Temporalio::Api::Failure::V1::Failure), + timed_out: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + completed: nil, + failed: nil, + cancelled: nil, + timed_out: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def completed + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def completed=(value) + end + + sig { void } + def clear_completed + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failed + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failed=(value) + end + + sig { void } + def clear_failed + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def cancelled + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def cancelled=(value) + end + + sig { void } + def clear_cancelled + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def timed_out + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def timed_out=(value) + end + + sig { void } + def clear_timed_out + end + + sig { returns(T.nilable(Symbol)) } + def status + 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::Internal::Bridge::Api::Nexus::NexusOperationResult) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Nexus::NexusOperationResult).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::Nexus::NexusOperationResult) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Nexus::NexusOperationResult, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A response to a Nexus task +class Temporalio::Internal::Bridge::Api::Nexus::NexusTaskCompletion + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + completed: T.nilable(Temporalio::Api::Nexus::V1::Response), + error: T.nilable(Temporalio::Api::Nexus::V1::HandlerError), + ack_cancel: T.nilable(T::Boolean), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + task_token: "", + completed: nil, + error: nil, + ack_cancel: false, + failure: nil + ) + end + + # The unique identifier for this task provided in the poll response + sig { returns(String) } + def task_token + end + + # The unique identifier for this task provided in the poll response + sig { params(value: String).void } + def task_token=(value) + end + + # The unique identifier for this task provided in the poll response + sig { void } + def clear_task_token + end + + # The handler completed (successfully or not). Note that the response kind must match the +# request kind (start or cancel). + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::Response)) } + def completed + end + + # The handler completed (successfully or not). Note that the response kind must match the +# request kind (start or cancel). + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::Response)).void } + def completed=(value) + end + + # The handler completed (successfully or not). Note that the response kind must match the +# request kind (start or cancel). + sig { void } + def clear_completed + end + + # The handler could not complete the request for some reason. Deprecated, use failure. + sig { returns(T.nilable(Temporalio::Api::Nexus::V1::HandlerError)) } + def error + end + + # The handler could not complete the request for some reason. Deprecated, use failure. + sig { params(value: T.nilable(Temporalio::Api::Nexus::V1::HandlerError)).void } + def error=(value) + end + + # The handler could not complete the request for some reason. Deprecated, use failure. + sig { void } + def clear_error + end + + # The lang SDK acknowledges that it is responding to a `CancelNexusTask` and thus the +# response is irrelevant. This is not the only way to respond to a cancel, the other +# variants can still be used, but this variant should be used when the handler was aborted +# by cancellation. + sig { returns(T::Boolean) } + def ack_cancel + end + + # The lang SDK acknowledges that it is responding to a `CancelNexusTask` and thus the +# response is irrelevant. This is not the only way to respond to a cancel, the other +# variants can still be used, but this variant should be used when the handler was aborted +# by cancellation. + sig { params(value: T::Boolean).void } + def ack_cancel=(value) + end + + # The lang SDK acknowledges that it is responding to a `CancelNexusTask` and thus the +# response is irrelevant. This is not the only way to respond to a cancel, the other +# variants can still be used, but this variant should be used when the handler was aborted +# by cancellation. + sig { void } + def clear_ack_cancel + end + + # The handler could not complete the request for some reason. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # The handler could not complete the request for some reason. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # The handler could not complete the request for some reason. + sig { void } + def clear_failure + end + + sig { returns(T.nilable(Symbol)) } + def status + 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::Internal::Bridge::Api::Nexus::NexusTaskCompletion) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Nexus::NexusTaskCompletion).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::Nexus::NexusTaskCompletion) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Nexus::NexusTaskCompletion, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::Nexus::NexusTask + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task: T.nilable(Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueResponse), + cancel_task: T.nilable(Temporalio::Internal::Bridge::Api::Nexus::CancelNexusTask), + request_deadline: T.nilable(Google::Protobuf::Timestamp), + endpoint: T.nilable(String) + ).void + end + def initialize( + task: nil, + cancel_task: nil, + request_deadline: nil, + endpoint: "" + ) + end + + # A nexus task from server + sig { returns(T.nilable(Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueResponse)) } + def task + end + + # A nexus task from server + sig { params(value: T.nilable(Temporalio::Api::WorkflowService::V1::PollNexusTaskQueueResponse)).void } + def task=(value) + end + + # A nexus task from server + sig { void } + def clear_task + end + + # A request by Core to notify an in-progress operation handler that it should cancel. This +# is distinct from a `CancelOperationRequest` from the server, which results from the user +# requesting the cancellation of an operation. Handling this variant should result in +# something like cancelling a cancellation token given to the user's operation handler. +# +# These do not count as a separate task for the purposes of completing all issued tasks, +# but rather count as a sort of modification to the already-issued task which is being +# cancelled. +# +# EX: Core knows the nexus operation has timed out, and it does not make sense for the +# user's operation handler to continue doing work. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::Nexus::CancelNexusTask)) } + def cancel_task + end + + # A request by Core to notify an in-progress operation handler that it should cancel. This +# is distinct from a `CancelOperationRequest` from the server, which results from the user +# requesting the cancellation of an operation. Handling this variant should result in +# something like cancelling a cancellation token given to the user's operation handler. +# +# These do not count as a separate task for the purposes of completing all issued tasks, +# but rather count as a sort of modification to the already-issued task which is being +# cancelled. +# +# EX: Core knows the nexus operation has timed out, and it does not make sense for the +# user's operation handler to continue doing work. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::Nexus::CancelNexusTask)).void } + def cancel_task=(value) + end + + # A request by Core to notify an in-progress operation handler that it should cancel. This +# is distinct from a `CancelOperationRequest` from the server, which results from the user +# requesting the cancellation of an operation. Handling this variant should result in +# something like cancelling a cancellation token given to the user's operation handler. +# +# These do not count as a separate task for the purposes of completing all issued tasks, +# but rather count as a sort of modification to the already-issued task which is being +# cancelled. +# +# EX: Core knows the nexus operation has timed out, and it does not make sense for the +# user's operation handler to continue doing work. + sig { void } + def clear_cancel_task + end + + # The deadline for this request, parsed from the "Request-Timeout" header. +# Only set when variant is `task` and the header was present with a valid value. +# Represented as an absolute timestamp. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def request_deadline + end + + # The deadline for this request, parsed from the "Request-Timeout" header. +# Only set when variant is `task` and the header was present with a valid value. +# Represented as an absolute timestamp. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def request_deadline=(value) + end + + # The deadline for this request, parsed from the "Request-Timeout" header. +# Only set when variant is `task` and the header was present with a valid value. +# Represented as an absolute timestamp. + sig { void } + def clear_request_deadline + end + + # The endpoint this request was addressed to. Extracted from the request for convenient access. +# Only set when variant is `task`. + sig { returns(String) } + def endpoint + end + + # The endpoint this request was addressed to. Extracted from the request for convenient access. +# Only set when variant is `task`. + sig { params(value: String).void } + def endpoint=(value) + end + + # The endpoint this request was addressed to. Extracted from the request for convenient access. +# Only set when variant is `task`. + sig { void } + def clear_endpoint + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Internal::Bridge::Api::Nexus::NexusTask) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Nexus::NexusTask).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::Nexus::NexusTask) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Nexus::NexusTask, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::Nexus::CancelNexusTask + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + task_token: T.nilable(String), + reason: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + task_token: "", + reason: :TIMED_OUT + ) + end + + # The task token from the PollNexusTaskQueueResponse + sig { returns(String) } + def task_token + end + + # The task token from the PollNexusTaskQueueResponse + sig { params(value: String).void } + def task_token=(value) + end + + # The task token from the PollNexusTaskQueueResponse + sig { void } + def clear_task_token + end + + # Why Core is asking for this operation to be cancelled + sig { returns(T.any(Symbol, Integer)) } + def reason + end + + # Why Core is asking for this operation to be cancelled + sig { params(value: T.any(Symbol, String, Integer)).void } + def reason=(value) + end + + # Why Core is asking for this operation to be cancelled + sig { void } + def clear_reason + 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::Internal::Bridge::Api::Nexus::CancelNexusTask) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Nexus::CancelNexusTask).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::Nexus::CancelNexusTask) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::Nexus::CancelNexusTask, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::Nexus::NexusTaskCancelReason + self::TIMED_OUT = T.let(0, Integer) + self::WORKER_SHUTDOWN = T.let(1, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::Nexus::NexusOperationCancellationType + self::WAIT_CANCELLATION_COMPLETED = T.let(0, Integer) + self::ABANDON = T.let(1, Integer) + self::TRY_CANCEL = T.let(2, Integer) + self::WAIT_CANCELLATION_REQUESTED = T.let(3, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/workflow_activation/workflow_activation.rbi b/temporalio/rbi/temporalio/internal/bridge/api/workflow_activation/workflow_activation.rbi new file mode 100644 index 00000000..58244169 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/workflow_activation/workflow_activation.rbi @@ -0,0 +1,2808 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/workflow_activation/workflow_activation.proto +# typed: strict + +# An instruction to the lang sdk to run some workflow code, whether for the first time or from +# a cached state. +# +# ## Job ordering guarantees and semantics +# +# Core will, by default, order jobs within the activation as follows: +# 1. init workflow +# 2. patches +# 3. random-seed-updates +# 4. signals/updates +# 5. all others +# 6. local activity resolutions +# 7. queries +# 8. evictions +# +# This is because: +# * Patches are expected to apply to the entire activation +# * Signal and update handlers should be invoked before workflow routines are iterated. That is to +# say before the users' main workflow function and anything spawned by it is allowed to continue. +# * Local activities resolutions go after other normal jobs because while *not* replaying, they +# will always take longer than anything else that produces an immediate job (which is +# effectively instant). When *replaying* we need to scan ahead for LA markers so that we can +# resolve them in the same activation that they completed in when not replaying. However, doing +# so would, by default, put those resolutions *before* any other immediate jobs that happened +# in that same activation (prime example: cancelling not-wait-for-cancel activities). So, we do +# this to ensure the LA resolution happens after that cancel (or whatever else it may be) as it +# normally would have when executing. +# * Queries always go last (and, in fact, always come in their own activation) +# * Evictions also always come in their own activation +# +# Core does this reordering to ensure that langs observe jobs in the same order during replay as +# they would have during execution. However, in principle, this ordering is not necessary +# (excepting queries/evictions, which definitely must come last) if lang layers apply all jobs to +# state *first* (by resolving promises/futures, marking handlers to be invoked, etc as they iterate +# over the jobs) and then only *after* that is done, drive coroutines/threads/whatever. If +# execution works this way, then determinism is only impacted by the order routines are driven in +# (which must be stable based on lang implementation or convention), rather than the order jobs are +# processed. +# +# ## Evictions +# +# Evictions appear as an activations that contains only a `remove_from_cache` job. Such activations +# should not cause the workflow code to be invoked and may be responded to with an empty command +# list. +class Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + timestamp: T.nilable(Google::Protobuf::Timestamp), + is_replaying: T.nilable(T::Boolean), + history_length: T.nilable(Integer), + jobs: T.nilable(T::Array[T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivationJob)]), + available_internal_flags: T.nilable(T::Array[Integer]), + history_size_bytes: T.nilable(Integer), + continue_as_new_suggested: T.nilable(T::Boolean), + deployment_version_for_current_task: T.nilable(Temporalio::Internal::Bridge::Api::Common::WorkerDeploymentVersion), + last_sdk_version: T.nilable(String), + suggest_continue_as_new_reasons: T.nilable(T::Array[T.any(Symbol, String, Integer)]), + target_worker_deployment_version_changed: T.nilable(T::Boolean) + ).void + end + def initialize( + run_id: "", + timestamp: nil, + is_replaying: false, + history_length: 0, + jobs: [], + available_internal_flags: [], + history_size_bytes: 0, + continue_as_new_suggested: false, + deployment_version_for_current_task: nil, + last_sdk_version: "", + suggest_continue_as_new_reasons: [], + target_worker_deployment_version_changed: false + ) + end + + # The id of the currently active run of the workflow. Also used as a cache key. There may +# only ever be one active workflow task (and hence activation) of a run at one time. + sig { returns(String) } + def run_id + end + + # The id of the currently active run of the workflow. Also used as a cache key. There may +# only ever be one active workflow task (and hence activation) of a run at one time. + sig { params(value: String).void } + def run_id=(value) + end + + # The id of the currently active run of the workflow. Also used as a cache key. There may +# only ever be one active workflow task (and hence activation) of a run at one time. + sig { void } + def clear_run_id + end + + # The current time as understood by the workflow, which is set by workflow task started events + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def timestamp + end + + # The current time as understood by the workflow, which is set by workflow task started events + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def timestamp=(value) + end + + # The current time as understood by the workflow, which is set by workflow task started events + sig { void } + def clear_timestamp + end + + # Whether or not the activation is replaying past events + sig { returns(T::Boolean) } + def is_replaying + end + + # Whether or not the activation is replaying past events + sig { params(value: T::Boolean).void } + def is_replaying=(value) + end + + # Whether or not the activation is replaying past events + sig { void } + def clear_is_replaying + end + + # Current history length as determined by the event id of the most recently processed event. +# This ensures that the number is always deterministic + sig { returns(Integer) } + def history_length + end + + # Current history length as determined by the event id of the most recently processed event. +# This ensures that the number is always deterministic + sig { params(value: Integer).void } + def history_length=(value) + end + + # Current history length as determined by the event id of the most recently processed event. +# This ensures that the number is always deterministic + sig { void } + def clear_history_length + end + + # The things to do upon activating the workflow + sig { returns(T::Array[T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivationJob)]) } + def jobs + end + + # The things to do upon activating the workflow + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def jobs=(value) + end + + # The things to do upon activating the workflow + sig { void } + def clear_jobs + end + + # Internal flags which are available for use by lang. If `is_replaying` is false, all +# internal flags may be used. This is not a delta - all previously used flags always +# appear since this representation is cheap. + sig { returns(T::Array[Integer]) } + def available_internal_flags + end + + # Internal flags which are available for use by lang. If `is_replaying` is false, all +# internal flags may be used. This is not a delta - all previously used flags always +# appear since this representation is cheap. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def available_internal_flags=(value) + end + + # Internal flags which are available for use by lang. If `is_replaying` is false, all +# internal flags may be used. This is not a delta - all previously used flags always +# appear since this representation is cheap. + sig { void } + def clear_available_internal_flags + end + + # The history size in bytes as of the last WFT started event + sig { returns(Integer) } + def history_size_bytes + end + + # The history size in bytes as of the last WFT started event + sig { params(value: Integer).void } + def history_size_bytes=(value) + end + + # The history size in bytes as of the last WFT started event + sig { void } + def clear_history_size_bytes + end + + # Set true if the most recent WFT started event had this suggestion + sig { returns(T::Boolean) } + def continue_as_new_suggested + end + + # Set true if the most recent WFT started event had this suggestion + sig { params(value: T::Boolean).void } + def continue_as_new_suggested=(value) + end + + # Set true if the most recent WFT started event had this suggestion + sig { void } + def clear_continue_as_new_suggested + end + + # Set to the deployment version of the worker that processed this task, +# which may be empty. During replay this version may not equal the version +# of the replaying worker. If not replaying and this worker has a defined +# Deployment Version, it will equal that. It will also be empty for +# evict-only activations. The deployment name may be empty, but not the +# build id, if this worker was using the deprecated Build ID-only +# feature(s). + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::Common::WorkerDeploymentVersion)) } + def deployment_version_for_current_task + end + + # Set to the deployment version of the worker that processed this task, +# which may be empty. During replay this version may not equal the version +# of the replaying worker. If not replaying and this worker has a defined +# Deployment Version, it will equal that. It will also be empty for +# evict-only activations. The deployment name may be empty, but not the +# build id, if this worker was using the deprecated Build ID-only +# feature(s). + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::Common::WorkerDeploymentVersion)).void } + def deployment_version_for_current_task=(value) + end + + # Set to the deployment version of the worker that processed this task, +# which may be empty. During replay this version may not equal the version +# of the replaying worker. If not replaying and this worker has a defined +# Deployment Version, it will equal that. It will also be empty for +# evict-only activations. The deployment name may be empty, but not the +# build id, if this worker was using the deprecated Build ID-only +# feature(s). + sig { void } + def clear_deployment_version_for_current_task + end + + # The last seen SDK version from the most recent WFT completed event + sig { returns(String) } + def last_sdk_version + end + + # The last seen SDK version from the most recent WFT completed event + sig { params(value: String).void } + def last_sdk_version=(value) + end + + # The last seen SDK version from the most recent WFT completed event + sig { void } + def clear_last_sdk_version + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { returns(T::Array[T.any(Symbol, Integer)]) } + def suggest_continue_as_new_reasons + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def suggest_continue_as_new_reasons=(value) + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { void } + def clear_suggest_continue_as_new_reasons + end + + # True if Workflow's Target Worker Deployment Version is different from its Pinned Version and +# the workflow is Pinned. +# Experimental. + sig { returns(T::Boolean) } + def target_worker_deployment_version_changed + end + + # True if Workflow's Target Worker Deployment Version is different from its Pinned Version and +# the workflow is Pinned. +# Experimental. + sig { params(value: T::Boolean).void } + def target_worker_deployment_version_changed=(value) + end + + # True if Workflow's Target Worker Deployment Version is different from its Pinned Version and +# the workflow is Pinned. +# Experimental. + sig { void } + def clear_target_worker_deployment_version_changed + 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::Internal::Bridge::Api::WorkflowActivation::WorkflowActivation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivationJob + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + initialize_workflow: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow), + fire_timer: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::FireTimer), + update_random_seed: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::UpdateRandomSeed), + query_workflow: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::QueryWorkflow), + cancel_workflow: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::CancelWorkflow), + signal_workflow: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::SignalWorkflow), + resolve_activity: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveActivity), + notify_has_patch: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::NotifyHasPatch), + resolve_child_workflow_execution_start: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStart), + resolve_child_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecution), + resolve_signal_external_workflow: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveSignalExternalWorkflow), + resolve_request_cancel_external_workflow: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveRequestCancelExternalWorkflow), + do_update: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate), + resolve_nexus_operation_start: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperationStart), + resolve_nexus_operation: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperation), + remove_from_cache: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache) + ).void + end + def initialize( + initialize_workflow: nil, + fire_timer: nil, + update_random_seed: nil, + query_workflow: nil, + cancel_workflow: nil, + signal_workflow: nil, + resolve_activity: nil, + notify_has_patch: nil, + resolve_child_workflow_execution_start: nil, + resolve_child_workflow_execution: nil, + resolve_signal_external_workflow: nil, + resolve_request_cancel_external_workflow: nil, + do_update: nil, + resolve_nexus_operation_start: nil, + resolve_nexus_operation: nil, + remove_from_cache: nil + ) + end + + # A workflow is starting, record all of the information from its start event + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow)) } + def initialize_workflow + end + + # A workflow is starting, record all of the information from its start event + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow)).void } + def initialize_workflow=(value) + end + + # A workflow is starting, record all of the information from its start event + sig { void } + def clear_initialize_workflow + end + + # A timer has fired, allowing whatever was waiting on it (if anything) to proceed + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::FireTimer)) } + def fire_timer + end + + # A timer has fired, allowing whatever was waiting on it (if anything) to proceed + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::FireTimer)).void } + def fire_timer=(value) + end + + # A timer has fired, allowing whatever was waiting on it (if anything) to proceed + sig { void } + def clear_fire_timer + end + + # Workflow was reset. The randomness seed must be updated. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::UpdateRandomSeed)) } + def update_random_seed + end + + # Workflow was reset. The randomness seed must be updated. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::UpdateRandomSeed)).void } + def update_random_seed=(value) + end + + # Workflow was reset. The randomness seed must be updated. + sig { void } + def clear_update_random_seed + end + + # A request to query the workflow was received. It is guaranteed that queries (one or more) +# always come in their own activation after other mutating jobs. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::QueryWorkflow)) } + def query_workflow + end + + # A request to query the workflow was received. It is guaranteed that queries (one or more) +# always come in their own activation after other mutating jobs. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::QueryWorkflow)).void } + def query_workflow=(value) + end + + # A request to query the workflow was received. It is guaranteed that queries (one or more) +# always come in their own activation after other mutating jobs. + sig { void } + def clear_query_workflow + end + + # A request to cancel the workflow was received. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::CancelWorkflow)) } + def cancel_workflow + end + + # A request to cancel the workflow was received. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::CancelWorkflow)).void } + def cancel_workflow=(value) + end + + # A request to cancel the workflow was received. + sig { void } + def clear_cancel_workflow + end + + # A request to signal the workflow was received. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::SignalWorkflow)) } + def signal_workflow + end + + # A request to signal the workflow was received. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::SignalWorkflow)).void } + def signal_workflow=(value) + end + + # A request to signal the workflow was received. + sig { void } + def clear_signal_workflow + end + + # An activity was resolved, result could be completed, failed or cancelled + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveActivity)) } + def resolve_activity + end + + # An activity was resolved, result could be completed, failed or cancelled + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveActivity)).void } + def resolve_activity=(value) + end + + # An activity was resolved, result could be completed, failed or cancelled + sig { void } + def clear_resolve_activity + end + + # A patch marker has been detected and lang is being told that change exists. This +# job is strange in that it is sent pre-emptively to lang without any corresponding +# command being sent first. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::NotifyHasPatch)) } + def notify_has_patch + end + + # A patch marker has been detected and lang is being told that change exists. This +# job is strange in that it is sent pre-emptively to lang without any corresponding +# command being sent first. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::NotifyHasPatch)).void } + def notify_has_patch=(value) + end + + # A patch marker has been detected and lang is being told that change exists. This +# job is strange in that it is sent pre-emptively to lang without any corresponding +# command being sent first. + sig { void } + def clear_notify_has_patch + end + + # A child workflow execution has started or failed to start + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStart)) } + def resolve_child_workflow_execution_start + end + + # A child workflow execution has started or failed to start + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStart)).void } + def resolve_child_workflow_execution_start=(value) + end + + # A child workflow execution has started or failed to start + sig { void } + def clear_resolve_child_workflow_execution_start + end + + # A child workflow was resolved, result could be completed or failed + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecution)) } + def resolve_child_workflow_execution + end + + # A child workflow was resolved, result could be completed or failed + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecution)).void } + def resolve_child_workflow_execution=(value) + end + + # A child workflow was resolved, result could be completed or failed + sig { void } + def clear_resolve_child_workflow_execution + end + + # An attempt to signal an external workflow resolved + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveSignalExternalWorkflow)) } + def resolve_signal_external_workflow + end + + # An attempt to signal an external workflow resolved + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveSignalExternalWorkflow)).void } + def resolve_signal_external_workflow=(value) + end + + # An attempt to signal an external workflow resolved + sig { void } + def clear_resolve_signal_external_workflow + end + + # An attempt to cancel an external workflow resolved + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveRequestCancelExternalWorkflow)) } + def resolve_request_cancel_external_workflow + end + + # An attempt to cancel an external workflow resolved + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveRequestCancelExternalWorkflow)).void } + def resolve_request_cancel_external_workflow=(value) + end + + # An attempt to cancel an external workflow resolved + sig { void } + def clear_resolve_request_cancel_external_workflow + end + + # A request to handle a workflow update. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate)) } + def do_update + end + + # A request to handle a workflow update. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate)).void } + def do_update=(value) + end + + # A request to handle a workflow update. + sig { void } + def clear_do_update + end + + # A nexus operation started. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperationStart)) } + def resolve_nexus_operation_start + end + + # A nexus operation started. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperationStart)).void } + def resolve_nexus_operation_start=(value) + end + + # A nexus operation started. + sig { void } + def clear_resolve_nexus_operation_start + end + + # A nexus operation resolved. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperation)) } + def resolve_nexus_operation + end + + # A nexus operation resolved. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperation)).void } + def resolve_nexus_operation=(value) + end + + # A nexus operation resolved. + sig { void } + def clear_resolve_nexus_operation + end + + # Remove the workflow identified by the [WorkflowActivation] containing this job from the +# cache after performing the activation. It is guaranteed that this will be the only job +# in the activation if present. + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache)) } + def remove_from_cache + end + + # Remove the workflow identified by the [WorkflowActivation] containing this job from the +# cache after performing the activation. It is guaranteed that this will be the only job +# in the activation if present. + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache)).void } + def remove_from_cache=(value) + end + + # Remove the workflow identified by the [WorkflowActivation] containing this job from the +# cache after performing the activation. It is guaranteed that this will be the only job +# in the activation if present. + sig { void } + def clear_remove_from_cache + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Internal::Bridge::Api::WorkflowActivation::WorkflowActivationJob) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivationJob).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivationJob) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::WorkflowActivationJob, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Initialize a new workflow +class Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_type: T.nilable(String), + workflow_id: T.nilable(String), + arguments: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + randomness_seed: T.nilable(Integer), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + identity: T.nilable(String), + parent_workflow_info: T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + continued_from_execution_run_id: T.nilable(String), + continued_initiator: T.nilable(T.any(Symbol, String, Integer)), + continued_failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + last_completion_result: T.nilable(Temporalio::Api::Common::V1::Payloads), + first_execution_run_id: T.nilable(String), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + attempt: T.nilable(Integer), + cron_schedule: T.nilable(String), + workflow_execution_expiration_time: T.nilable(Google::Protobuf::Timestamp), + cron_schedule_to_schedule_interval: T.nilable(Google::Protobuf::Duration), + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + start_time: T.nilable(Google::Protobuf::Timestamp), + root_workflow: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution), + priority: T.nilable(Temporalio::Api::Common::V1::Priority) + ).void + end + def initialize( + workflow_type: "", + workflow_id: "", + arguments: [], + randomness_seed: 0, + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + identity: "", + parent_workflow_info: nil, + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + continued_from_execution_run_id: "", + continued_initiator: :CONTINUE_AS_NEW_INITIATOR_UNSPECIFIED, + continued_failure: nil, + last_completion_result: nil, + first_execution_run_id: "", + retry_policy: nil, + attempt: 0, + cron_schedule: "", + workflow_execution_expiration_time: nil, + cron_schedule_to_schedule_interval: nil, + memo: nil, + search_attributes: nil, + start_time: nil, + root_workflow: nil, + priority: nil + ) + end + + # The identifier the lang-specific sdk uses to execute workflow code + sig { returns(String) } + def workflow_type + end + + # The identifier the lang-specific sdk uses to execute workflow code + sig { params(value: String).void } + def workflow_type=(value) + end + + # The identifier the lang-specific sdk uses to execute workflow code + sig { void } + def clear_workflow_type + end + + # The workflow id used on the temporal server + sig { returns(String) } + def workflow_id + end + + # The workflow id used on the temporal server + sig { params(value: String).void } + def workflow_id=(value) + end + + # The workflow id used on the temporal server + sig { void } + def clear_workflow_id + end + + # Inputs to the workflow code + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def arguments + end + + # Inputs to the workflow code + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def arguments=(value) + end + + # Inputs to the workflow code + sig { void } + def clear_arguments + end + + # The seed must be used to initialize the random generator used by SDK. +# RandomSeedUpdatedAttributes are used to deliver seed updates. + sig { returns(Integer) } + def randomness_seed + end + + # The seed must be used to initialize the random generator used by SDK. +# RandomSeedUpdatedAttributes are used to deliver seed updates. + sig { params(value: Integer).void } + def randomness_seed=(value) + end + + # The seed must be used to initialize the random generator used by SDK. +# RandomSeedUpdatedAttributes are used to deliver seed updates. + sig { void } + def clear_randomness_seed + end + + # Used to add metadata e.g. for tracing and auth, meant to be read and written to by interceptors. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + # Used to add metadata e.g. for tracing and auth, meant to be read and written to by interceptors. + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + # Used to add metadata e.g. for tracing and auth, meant to be read and written to by interceptors. + sig { void } + def clear_headers + end + + # Identity of the client who requested this execution + sig { returns(String) } + def identity + end + + # Identity of the client who requested this execution + sig { params(value: String).void } + def identity=(value) + end + + # Identity of the client who requested this execution + sig { void } + def clear_identity + end + + # If this workflow is a child, information about the parent + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution)) } + def parent_workflow_info + end + + # If this workflow is a child, information about the parent + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution)).void } + def parent_workflow_info=(value) + end + + # If this workflow is a child, information about the parent + sig { void } + def clear_parent_workflow_info + end + + # Total workflow execution timeout including retries and continue as new. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + # Total workflow execution timeout including retries and continue as new. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + # Total workflow execution timeout including retries and continue as new. + sig { void } + def clear_workflow_execution_timeout + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # Run id of the previous workflow which continued-as-new or retired or cron executed into this +# workflow, if any. + sig { returns(String) } + def continued_from_execution_run_id + end + + # Run id of the previous workflow which continued-as-new or retired or cron executed into this +# workflow, if any. + sig { params(value: String).void } + def continued_from_execution_run_id=(value) + end + + # Run id of the previous workflow which continued-as-new or retired or cron executed into this +# workflow, if any. + sig { void } + def clear_continued_from_execution_run_id + end + + # If this workflow was a continuation, indicates the type of continuation. + sig { returns(T.any(Symbol, Integer)) } + def continued_initiator + end + + # If this workflow was a continuation, indicates the type of continuation. + sig { params(value: T.any(Symbol, String, Integer)).void } + def continued_initiator=(value) + end + + # If this workflow was a continuation, indicates the type of continuation. + sig { void } + def clear_continued_initiator + end + + # If this workflow was a continuation and that continuation failed, the details of that. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def continued_failure + end + + # If this workflow was a continuation and that continuation failed, the details of that. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def continued_failure=(value) + end + + # If this workflow was a continuation and that continuation failed, the details of that. + sig { void } + def clear_continued_failure + end + + # If this workflow was a continuation and that continuation completed, the details of that. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payloads)) } + def last_completion_result + end + + # If this workflow was a continuation and that continuation completed, the details of that. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payloads)).void } + def last_completion_result=(value) + end + + # If this workflow was a continuation and that continuation completed, the details of that. + sig { void } + def clear_last_completion_result + end + + # This is the very first run id the workflow ever had, following continuation chains. + sig { returns(String) } + def first_execution_run_id + end + + # This is the very first run id the workflow ever had, following continuation chains. + sig { params(value: String).void } + def first_execution_run_id=(value) + end + + # This is the very first run id the workflow ever had, following continuation chains. + sig { void } + def clear_first_execution_run_id + end + + # This workflow's retry policy + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # This workflow's retry policy + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # This workflow's retry policy + sig { void } + def clear_retry_policy + end + + # Starting at 1, the number of times we have tried to execute this workflow + sig { returns(Integer) } + def attempt + end + + # Starting at 1, the number of times we have tried to execute this workflow + sig { params(value: Integer).void } + def attempt=(value) + end + + # Starting at 1, the number of times we have tried to execute this workflow + sig { void } + def clear_attempt + end + + # If this workflow runs on a cron schedule, it will appear here + sig { returns(String) } + def cron_schedule + end + + # If this workflow runs on a cron schedule, it will appear here + sig { params(value: String).void } + def cron_schedule=(value) + end + + # If this workflow runs on a cron schedule, it will appear here + sig { void } + def clear_cron_schedule + end + + # The absolute time at which the workflow will be timed out. +# This is passed without change to the next run/retry of a workflow. + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def workflow_execution_expiration_time + end + + # The absolute time at which the workflow will be timed out. +# This is passed without change to the next run/retry of a workflow. + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def workflow_execution_expiration_time=(value) + end + + # The absolute time at which the workflow will be timed out. +# This is passed without change to the next run/retry of a workflow. + sig { void } + def clear_workflow_execution_expiration_time + end + + # For a cron workflow, this contains the amount of time between when this iteration of +# the cron workflow was scheduled and when it should run next per its cron_schedule. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def cron_schedule_to_schedule_interval + end + + # For a cron workflow, this contains the amount of time between when this iteration of +# the cron workflow was scheduled and when it should run next per its cron_schedule. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def cron_schedule_to_schedule_interval=(value) + end + + # For a cron workflow, this contains the amount of time between when this iteration of +# the cron workflow was scheduled and when it should run next per its cron_schedule. + sig { void } + def clear_cron_schedule_to_schedule_interval + end + + # User-defined memo + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def memo + end + + # User-defined memo + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def memo=(value) + end + + # User-defined memo + sig { void } + def clear_memo + end + + # Search attributes created/updated when this workflow was started + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # Search attributes created/updated when this workflow was started + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # Search attributes created/updated when this workflow was started + sig { void } + def clear_search_attributes + end + + # When the workflow execution started event was first written + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def start_time + end + + # When the workflow execution started event was first written + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def start_time=(value) + end + + # When the workflow execution started event was first written + sig { void } + def clear_start_time + end + + # Contains information about the root workflow execution. It is possible for the namespace to +# be different than this workflow if using OSS and cross-namespace children, but this +# information is not retained. Users should take care to track it by other means in such +# situations. +# +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# +# See field in WorkflowExecutionStarted for more detail. + sig { returns(T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)) } + def root_workflow + end + + # Contains information about the root workflow execution. It is possible for the namespace to +# be different than this workflow if using OSS and cross-namespace children, but this +# information is not retained. Users should take care to track it by other means in such +# situations. +# +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# +# See field in WorkflowExecutionStarted for more detail. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::WorkflowExecution)).void } + def root_workflow=(value) + end + + # Contains information about the root workflow execution. It is possible for the namespace to +# be different than this workflow if using OSS and cross-namespace children, but this +# information is not retained. Users should take care to track it by other means in such +# situations. +# +# The root workflow execution is defined as follows: +# 1. A workflow without parent workflow is its own root workflow. +# 2. A workflow that has a parent workflow has the same root workflow as its parent workflow. +# +# See field in WorkflowExecutionStarted for more detail. + sig { void } + def clear_root_workflow + end + + # Priority of this workflow execution + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # Priority of this workflow execution + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # Priority of this workflow execution + sig { void } + def clear_priority + 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::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::InitializeWorkflow, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Notify a workflow that a timer has fired +class Temporalio::Internal::Bridge::Api::WorkflowActivation::FireTimer + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer) + ).void + end + def initialize( + seq: 0 + ) + end + + # Sequence number as provided by lang in the corresponding StartTimer command + sig { returns(Integer) } + def seq + end + + # Sequence number as provided by lang in the corresponding StartTimer command + sig { params(value: Integer).void } + def seq=(value) + end + + # Sequence number as provided by lang in the corresponding StartTimer command + sig { void } + def clear_seq + 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::Internal::Bridge::Api::WorkflowActivation::FireTimer) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::FireTimer).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::FireTimer) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::FireTimer, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Notify a workflow that an activity has been resolved +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveActivity + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + result: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::ActivityResolution), + is_local: T.nilable(T::Boolean) + ).void + end + def initialize( + seq: 0, + result: nil, + is_local: false + ) + end + + # Sequence number as provided by lang in the corresponding ScheduleActivity command + sig { returns(Integer) } + def seq + end + + # Sequence number as provided by lang in the corresponding ScheduleActivity command + sig { params(value: Integer).void } + def seq=(value) + end + + # Sequence number as provided by lang in the corresponding ScheduleActivity command + sig { void } + def clear_seq + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::ActivityResolution)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ActivityResult::ActivityResolution)).void } + def result=(value) + end + + sig { void } + def clear_result + end + + # Set to true if the resolution is for a local activity. This is used internally by Core and +# lang does not need to care about it. + sig { returns(T::Boolean) } + def is_local + end + + # Set to true if the resolution is for a local activity. This is used internally by Core and +# lang does not need to care about it. + sig { params(value: T::Boolean).void } + def is_local=(value) + end + + # Set to true if the resolution is for a local activity. This is used internally by Core and +# lang does not need to care about it. + sig { void } + def clear_is_local + 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::Internal::Bridge::Api::WorkflowActivation::ResolveActivity) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveActivity).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveActivity) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveActivity, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Notify a workflow that a start child workflow execution request has succeeded, failed or was +# cancelled. +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStart + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + succeeded: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartSuccess), + failed: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartFailure), + cancelled: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartCancelled) + ).void + end + def initialize( + seq: 0, + succeeded: nil, + failed: nil, + cancelled: nil + ) + end + + # Sequence number as provided by lang in the corresponding StartChildWorkflowExecution command + sig { returns(Integer) } + def seq + end + + # Sequence number as provided by lang in the corresponding StartChildWorkflowExecution command + sig { params(value: Integer).void } + def seq=(value) + end + + # Sequence number as provided by lang in the corresponding StartChildWorkflowExecution command + sig { void } + def clear_seq + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartSuccess)) } + def succeeded + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartSuccess)).void } + def succeeded=(value) + end + + sig { void } + def clear_succeeded + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartFailure)) } + def failed + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartFailure)).void } + def failed=(value) + end + + sig { void } + def clear_failed + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartCancelled)) } + def cancelled + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartCancelled)).void } + def cancelled=(value) + end + + sig { void } + def clear_cancelled + end + + sig { returns(T.nilable(Symbol)) } + def status + 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::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStart) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStart).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStart) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStart, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Simply pass the run_id to lang +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartSuccess + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String) + ).void + end + def initialize( + run_id: "" + ) + end + + sig { returns(String) } + def run_id + end + + sig { params(value: String).void } + def run_id=(value) + end + + sig { void } + def clear_run_id + end + + sig { params(field: String).returns(T.untyped) } + def [](field) + end + + sig { params(field: String, value: T.untyped).void } + def []=(field, value) + end + + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h + end + + sig { params(str: String).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartSuccess) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartSuccess).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartSuccess) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartSuccess, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Provide lang the cause of failure +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartFailure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_id: T.nilable(String), + workflow_type: T.nilable(String), + cause: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + workflow_id: "", + workflow_type: "", + cause: :START_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_UNSPECIFIED + ) + end + + # Lang should have this information but it's more convenient to pass it back +# for error construction on the lang side. + sig { returns(String) } + def workflow_id + end + + # Lang should have this information but it's more convenient to pass it back +# for error construction on the lang side. + sig { params(value: String).void } + def workflow_id=(value) + end + + # Lang should have this information but it's more convenient to pass it back +# for error construction on the lang side. + sig { void } + def clear_workflow_id + end + + sig { returns(String) } + def workflow_type + end + + sig { params(value: String).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + end + + sig { returns(T.any(Symbol, Integer)) } + def cause + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def cause=(value) + end + + sig { void } + def clear_cause + 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::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartFailure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartFailure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartFailure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartFailure, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# `failure` should be ChildWorkflowFailure with cause set to CancelledFailure. +# The failure is constructed in core for lang's convenience. +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartCancelled + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartCancelled) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartCancelled).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartCancelled) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecutionStartCancelled, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Notify a workflow that a child workflow execution has been resolved +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + result: T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult) + ).void + end + def initialize( + seq: 0, + result: nil + ) + end + + # Sequence number as provided by lang in the corresponding StartChildWorkflowExecution command + sig { returns(Integer) } + def seq + end + + # Sequence number as provided by lang in the corresponding StartChildWorkflowExecution command + sig { params(value: Integer).void } + def seq=(value) + end + + # Sequence number as provided by lang in the corresponding StartChildWorkflowExecution command + sig { void } + def clear_seq + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult)).void } + def result=(value) + end + + sig { void } + def clear_result + 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::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveChildWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Update the workflow's random seed +class Temporalio::Internal::Bridge::Api::WorkflowActivation::UpdateRandomSeed + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + randomness_seed: T.nilable(Integer) + ).void + end + def initialize( + randomness_seed: 0 + ) + end + + sig { returns(Integer) } + def randomness_seed + end + + sig { params(value: Integer).void } + def randomness_seed=(value) + end + + sig { void } + def clear_randomness_seed + 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::Internal::Bridge::Api::WorkflowActivation::UpdateRandomSeed) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::UpdateRandomSeed).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::UpdateRandomSeed) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::UpdateRandomSeed, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Query a workflow +class Temporalio::Internal::Bridge::Api::WorkflowActivation::QueryWorkflow + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + query_id: T.nilable(String), + query_type: T.nilable(String), + arguments: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + query_id: "", + query_type: "", + arguments: [], + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload) + ) + end + + # For PollWFTResp `query` field, this will be set to the special value `legacy`. For the +# `queries` field, the server provides a unique identifier. If it is a `legacy` query, +# lang cannot issue any commands in response other than to answer the query. + sig { returns(String) } + def query_id + end + + # For PollWFTResp `query` field, this will be set to the special value `legacy`. For the +# `queries` field, the server provides a unique identifier. If it is a `legacy` query, +# lang cannot issue any commands in response other than to answer the query. + sig { params(value: String).void } + def query_id=(value) + end + + # For PollWFTResp `query` field, this will be set to the special value `legacy`. For the +# `queries` field, the server provides a unique identifier. If it is a `legacy` query, +# lang cannot issue any commands in response other than to answer the query. + sig { void } + def clear_query_id + end + + # The query's function/method/etc name + sig { returns(String) } + def query_type + end + + # The query's function/method/etc name + sig { params(value: String).void } + def query_type=(value) + end + + # The query's function/method/etc name + sig { void } + def clear_query_type + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def arguments + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def arguments=(value) + end + + sig { void } + def clear_arguments + end + + # Headers attached to the query + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + # Headers attached to the query + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + # Headers attached to the query + sig { void } + def clear_headers + 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::Internal::Bridge::Api::WorkflowActivation::QueryWorkflow) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::QueryWorkflow).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::QueryWorkflow) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::QueryWorkflow, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Cancel a running workflow +class Temporalio::Internal::Bridge::Api::WorkflowActivation::CancelWorkflow + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + reason: T.nilable(String) + ).void + end + def initialize( + reason: "" + ) + end + + # User-specified reason the cancel request was issued + sig { returns(String) } + def reason + end + + # User-specified reason the cancel request was issued + sig { params(value: String).void } + def reason=(value) + end + + # User-specified reason the cancel request was issued + sig { void } + def clear_reason + 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::Internal::Bridge::Api::WorkflowActivation::CancelWorkflow) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::CancelWorkflow).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::CancelWorkflow) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::CancelWorkflow, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Send a signal to a workflow +class Temporalio::Internal::Bridge::Api::WorkflowActivation::SignalWorkflow + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + signal_name: T.nilable(String), + input: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + identity: T.nilable(String), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + signal_name: "", + input: [], + identity: "", + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload) + ) + end + + sig { returns(String) } + def signal_name + end + + sig { params(value: String).void } + def signal_name=(value) + end + + sig { void } + def clear_signal_name + end + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def input + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def input=(value) + end + + sig { void } + def clear_input + end + + # Identity of the sender of the signal + sig { returns(String) } + def identity + end + + # Identity of the sender of the signal + sig { params(value: String).void } + def identity=(value) + end + + # Identity of the sender of the signal + sig { void } + def clear_identity + end + + # Headers attached to the signal + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + # Headers attached to the signal + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + # Headers attached to the signal + sig { void } + def clear_headers + 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::Internal::Bridge::Api::WorkflowActivation::SignalWorkflow) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::SignalWorkflow).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::SignalWorkflow) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::SignalWorkflow, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Inform lang what the result of a call to `patched` or similar API should be -- this is always +# sent pre-emptively, so any time it is sent the change is present +class Temporalio::Internal::Bridge::Api::WorkflowActivation::NotifyHasPatch + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + patch_id: T.nilable(String) + ).void + end + def initialize( + patch_id: "" + ) + end + + sig { returns(String) } + def patch_id + end + + sig { params(value: String).void } + def patch_id=(value) + end + + sig { void } + def clear_patch_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::Internal::Bridge::Api::WorkflowActivation::NotifyHasPatch) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::NotifyHasPatch).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::NotifyHasPatch) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::NotifyHasPatch, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveSignalExternalWorkflow + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + seq: 0, + failure: nil + ) + end + + # Sequence number as provided by lang in the corresponding SignalExternalWorkflowExecution +# command + sig { returns(Integer) } + def seq + end + + # Sequence number as provided by lang in the corresponding SignalExternalWorkflowExecution +# command + sig { params(value: Integer).void } + def seq=(value) + end + + # Sequence number as provided by lang in the corresponding SignalExternalWorkflowExecution +# command + sig { void } + def clear_seq + end + + # If populated, this signal either failed to be sent or was cancelled depending on failure +# type / info. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # If populated, this signal either failed to be sent or was cancelled depending on failure +# type / info. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # If populated, this signal either failed to be sent or was cancelled depending on failure +# type / info. + sig { void } + def clear_failure + 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::Internal::Bridge::Api::WorkflowActivation::ResolveSignalExternalWorkflow) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveSignalExternalWorkflow).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveSignalExternalWorkflow) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveSignalExternalWorkflow, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveRequestCancelExternalWorkflow + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + seq: 0, + failure: nil + ) + end + + # Sequence number as provided by lang in the corresponding +# RequestCancelExternalWorkflowExecution command + sig { returns(Integer) } + def seq + end + + # Sequence number as provided by lang in the corresponding +# RequestCancelExternalWorkflowExecution command + sig { params(value: Integer).void } + def seq=(value) + end + + # Sequence number as provided by lang in the corresponding +# RequestCancelExternalWorkflowExecution command + sig { void } + def clear_seq + end + + # If populated, this signal either failed to be sent or was cancelled depending on failure +# type / info. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + # If populated, this signal either failed to be sent or was cancelled depending on failure +# type / info. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + # If populated, this signal either failed to be sent or was cancelled depending on failure +# type / info. + sig { void } + def clear_failure + 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::Internal::Bridge::Api::WorkflowActivation::ResolveRequestCancelExternalWorkflow) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveRequestCancelExternalWorkflow).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveRequestCancelExternalWorkflow) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveRequestCancelExternalWorkflow, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Lang is requested to invoke an update handler on the workflow. Lang should invoke the update +# validator first (if requested). If it accepts the update, immediately invoke the update handler. +# Lang must reply to the activation containing this job with an `UpdateResponse`. +class Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + id: T.nilable(String), + protocol_instance_id: T.nilable(String), + name: T.nilable(String), + input: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + meta: T.nilable(Temporalio::Api::Update::V1::Meta), + run_validator: T.nilable(T::Boolean) + ).void + end + def initialize( + id: "", + protocol_instance_id: "", + name: "", + input: [], + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + meta: nil, + run_validator: false + ) + end + + # A workflow-unique identifier for this update + sig { returns(String) } + def id + end + + # A workflow-unique identifier for this update + sig { params(value: String).void } + def id=(value) + end + + # A workflow-unique identifier for this update + sig { void } + def clear_id + end + + # The protocol message instance ID - this is used to uniquely track the ID server side and +# internally. + sig { returns(String) } + def protocol_instance_id + end + + # The protocol message instance ID - this is used to uniquely track the ID server side and +# internally. + sig { params(value: String).void } + def protocol_instance_id=(value) + end + + # The protocol message instance ID - this is used to uniquely track the ID server side and +# internally. + sig { void } + def clear_protocol_instance_id + end + + # The name of the update handler + sig { returns(String) } + def name + end + + # The name of the update handler + sig { params(value: String).void } + def name=(value) + end + + # The name of the update handler + sig { void } + def clear_name + end + + # The input to the update + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def input + end + + # The input to the update + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def input=(value) + end + + # The input to the update + sig { void } + def clear_input + end + + # Headers attached to the update + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + # Headers attached to the update + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + # Headers attached to the update + sig { void } + def clear_headers + end + + # Remaining metadata associated with the update. The `update_id` field is stripped from here +# and moved to `id`, since it is guaranteed to be present. + sig { returns(T.nilable(Temporalio::Api::Update::V1::Meta)) } + def meta + end + + # Remaining metadata associated with the update. The `update_id` field is stripped from here +# and moved to `id`, since it is guaranteed to be present. + sig { params(value: T.nilable(Temporalio::Api::Update::V1::Meta)).void } + def meta=(value) + end + + # Remaining metadata associated with the update. The `update_id` field is stripped from here +# and moved to `id`, since it is guaranteed to be present. + sig { void } + def clear_meta + end + + # If set true, lang must run the update's validator before running the handler. This will be +# set false during replay, since validation is not re-run during replay. + sig { returns(T::Boolean) } + def run_validator + end + + # If set true, lang must run the update's validator before running the handler. This will be +# set false during replay, since validation is not re-run during replay. + sig { params(value: T::Boolean).void } + def run_validator=(value) + end + + # If set true, lang must run the update's validator before running the handler. This will be +# set false during replay, since validation is not re-run during replay. + sig { void } + def clear_run_validator + 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::Internal::Bridge::Api::WorkflowActivation::DoUpdate) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::DoUpdate, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperationStart + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + operation_token: T.nilable(String), + started_sync: T.nilable(T::Boolean), + failed: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + seq: 0, + operation_token: "", + started_sync: false, + failed: nil + ) + end + + # Sequence number as provided by lang in the corresponding ScheduleNexusOperation command + sig { returns(Integer) } + def seq + end + + # Sequence number as provided by lang in the corresponding ScheduleNexusOperation command + sig { params(value: Integer).void } + def seq=(value) + end + + # Sequence number as provided by lang in the corresponding ScheduleNexusOperation command + sig { void } + def clear_seq + end + + # The operation started asynchronously. Contains a token that can be used to perform +# operations on the started operation by, ex, clients. A `ResolveNexusOperation` job will +# follow at some point. + sig { returns(String) } + def operation_token + end + + # The operation started asynchronously. Contains a token that can be used to perform +# operations on the started operation by, ex, clients. A `ResolveNexusOperation` job will +# follow at some point. + sig { params(value: String).void } + def operation_token=(value) + end + + # The operation started asynchronously. Contains a token that can be used to perform +# operations on the started operation by, ex, clients. A `ResolveNexusOperation` job will +# follow at some point. + sig { void } + def clear_operation_token + end + + # If true the operation "started" but only because it's also already resolved. A +# `ResolveNexusOperation` job will be in the same activation. + sig { returns(T::Boolean) } + def started_sync + end + + # If true the operation "started" but only because it's also already resolved. A +# `ResolveNexusOperation` job will be in the same activation. + sig { params(value: T::Boolean).void } + def started_sync=(value) + end + + # If true the operation "started" but only because it's also already resolved. A +# `ResolveNexusOperation` job will be in the same activation. + sig { void } + def clear_started_sync + end + + # The operation either failed to start, was cancelled before it started, timed out, or +# failed synchronously. Details are included inside the message. In this case, the +# subsequent ResolveNexusOperation will never be sent. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failed + end + + # The operation either failed to start, was cancelled before it started, timed out, or +# failed synchronously. Details are included inside the message. In this case, the +# subsequent ResolveNexusOperation will never be sent. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failed=(value) + end + + # The operation either failed to start, was cancelled before it started, timed out, or +# failed synchronously. Details are included inside the message. In this case, the +# subsequent ResolveNexusOperation will never be sent. + sig { void } + def clear_failed + end + + sig { returns(T.nilable(Symbol)) } + def status + 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::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperationStart) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperationStart).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperationStart) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperationStart, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + result: T.nilable(Temporalio::Internal::Bridge::Api::Nexus::NexusOperationResult) + ).void + end + def initialize( + seq: 0, + result: nil + ) + end + + # Sequence number as provided by lang in the corresponding ScheduleNexusOperation command + sig { returns(Integer) } + def seq + end + + # Sequence number as provided by lang in the corresponding ScheduleNexusOperation command + sig { params(value: Integer).void } + def seq=(value) + end + + # Sequence number as provided by lang in the corresponding ScheduleNexusOperation command + sig { void } + def clear_seq + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::Nexus::NexusOperationResult)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::Nexus::NexusOperationResult)).void } + def result=(value) + end + + sig { void } + def clear_result + 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::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::ResolveNexusOperation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + message: T.nilable(String), + reason: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + message: "", + reason: :UNSPECIFIED + ) + end + + sig { returns(String) } + def message + end + + sig { params(value: String).void } + def message=(value) + end + + sig { void } + def clear_message + end + + sig { returns(T.any(Symbol, Integer)) } + def reason + end + + sig { params(value: T.any(Symbol, String, Integer)).void } + def reason=(value) + end + + sig { void } + def clear_reason + 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::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::WorkflowActivation::RemoveFromCache::EvictionReason + self::UNSPECIFIED = T.let(0, Integer) + self::CACHE_FULL = T.let(1, Integer) + self::CACHE_MISS = T.let(2, Integer) + self::NONDETERMINISM = T.let(3, Integer) + self::LANG_FAIL = T.let(4, Integer) + self::LANG_REQUESTED = T.let(5, Integer) + self::TASK_NOT_FOUND = T.let(6, Integer) + self::UNHANDLED_COMMAND = T.let(7, Integer) + self::FATAL = T.let(8, Integer) + self::PAGINATION_OR_HISTORY_FETCH = T.let(9, Integer) + self::WORKFLOW_EXECUTION_ENDING = T.let(10, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/workflow_commands/workflow_commands.rbi b/temporalio/rbi/temporalio/internal/bridge/api/workflow_commands/workflow_commands.rbi new file mode 100644 index 00000000..51f1db1c --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/workflow_commands/workflow_commands.rbi @@ -0,0 +1,3292 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/workflow_commands/workflow_commands.proto +# typed: strict + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::WorkflowCommand + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + user_metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + start_timer: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::StartTimer), + schedule_activity: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleActivity), + respond_to_query: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::QueryResult), + request_cancel_activity: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelActivity), + cancel_timer: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelTimer), + complete_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CompleteWorkflowExecution), + fail_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::FailWorkflowExecution), + continue_as_new_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution), + cancel_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelWorkflowExecution), + set_patch_marker: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::SetPatchMarker), + start_child_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::StartChildWorkflowExecution), + cancel_child_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelChildWorkflowExecution), + request_cancel_external_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelExternalWorkflowExecution), + signal_external_workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution), + cancel_signal_workflow: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelSignalWorkflow), + schedule_local_activity: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleLocalActivity), + request_cancel_local_activity: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelLocalActivity), + upsert_workflow_search_attributes: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes), + modify_workflow_properties: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ModifyWorkflowProperties), + update_response: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::UpdateResponse), + schedule_nexus_operation: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleNexusOperation), + request_cancel_nexus_operation: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelNexusOperation) + ).void + end + def initialize( + user_metadata: nil, + start_timer: nil, + schedule_activity: nil, + respond_to_query: nil, + request_cancel_activity: nil, + cancel_timer: nil, + complete_workflow_execution: nil, + fail_workflow_execution: nil, + continue_as_new_workflow_execution: nil, + cancel_workflow_execution: nil, + set_patch_marker: nil, + start_child_workflow_execution: nil, + cancel_child_workflow_execution: nil, + request_cancel_external_workflow_execution: nil, + signal_external_workflow_execution: nil, + cancel_signal_workflow: nil, + schedule_local_activity: nil, + request_cancel_local_activity: nil, + upsert_workflow_search_attributes: nil, + modify_workflow_properties: nil, + update_response: nil, + schedule_nexus_operation: nil, + request_cancel_nexus_operation: nil + ) + end + + # User metadata that may or may not be persisted into history depending on the command type. +# Lang layers are expected to expose the setting of the internals of this metadata on a +# per-command basis where applicable. + sig { returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) } + def user_metadata + end + + # User metadata that may or may not be persisted into history depending on the command type. +# Lang layers are expected to expose the setting of the internals of this metadata on a +# per-command basis where applicable. + sig { params(value: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)).void } + def user_metadata=(value) + end + + # User metadata that may or may not be persisted into history depending on the command type. +# Lang layers are expected to expose the setting of the internals of this metadata on a +# per-command basis where applicable. + sig { void } + def clear_user_metadata + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::StartTimer)) } + def start_timer + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::StartTimer)).void } + def start_timer=(value) + end + + sig { void } + def clear_start_timer + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleActivity)) } + def schedule_activity + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleActivity)).void } + def schedule_activity=(value) + end + + sig { void } + def clear_schedule_activity + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::QueryResult)) } + def respond_to_query + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::QueryResult)).void } + def respond_to_query=(value) + end + + sig { void } + def clear_respond_to_query + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelActivity)) } + def request_cancel_activity + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelActivity)).void } + def request_cancel_activity=(value) + end + + sig { void } + def clear_request_cancel_activity + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelTimer)) } + def cancel_timer + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelTimer)).void } + def cancel_timer=(value) + end + + sig { void } + def clear_cancel_timer + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CompleteWorkflowExecution)) } + def complete_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CompleteWorkflowExecution)).void } + def complete_workflow_execution=(value) + end + + sig { void } + def clear_complete_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::FailWorkflowExecution)) } + def fail_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::FailWorkflowExecution)).void } + def fail_workflow_execution=(value) + end + + sig { void } + def clear_fail_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution)) } + def continue_as_new_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution)).void } + def continue_as_new_workflow_execution=(value) + end + + sig { void } + def clear_continue_as_new_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelWorkflowExecution)) } + def cancel_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelWorkflowExecution)).void } + def cancel_workflow_execution=(value) + end + + sig { void } + def clear_cancel_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::SetPatchMarker)) } + def set_patch_marker + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::SetPatchMarker)).void } + def set_patch_marker=(value) + end + + sig { void } + def clear_set_patch_marker + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::StartChildWorkflowExecution)) } + def start_child_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::StartChildWorkflowExecution)).void } + def start_child_workflow_execution=(value) + end + + sig { void } + def clear_start_child_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelChildWorkflowExecution)) } + def cancel_child_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelChildWorkflowExecution)).void } + def cancel_child_workflow_execution=(value) + end + + sig { void } + def clear_cancel_child_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelExternalWorkflowExecution)) } + def request_cancel_external_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelExternalWorkflowExecution)).void } + def request_cancel_external_workflow_execution=(value) + end + + sig { void } + def clear_request_cancel_external_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution)) } + def signal_external_workflow_execution + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution)).void } + def signal_external_workflow_execution=(value) + end + + sig { void } + def clear_signal_external_workflow_execution + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelSignalWorkflow)) } + def cancel_signal_workflow + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelSignalWorkflow)).void } + def cancel_signal_workflow=(value) + end + + sig { void } + def clear_cancel_signal_workflow + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleLocalActivity)) } + def schedule_local_activity + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleLocalActivity)).void } + def schedule_local_activity=(value) + end + + sig { void } + def clear_schedule_local_activity + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelLocalActivity)) } + def request_cancel_local_activity + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelLocalActivity)).void } + def request_cancel_local_activity=(value) + end + + sig { void } + def clear_request_cancel_local_activity + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes)) } + def upsert_workflow_search_attributes + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes)).void } + def upsert_workflow_search_attributes=(value) + end + + sig { void } + def clear_upsert_workflow_search_attributes + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ModifyWorkflowProperties)) } + def modify_workflow_properties + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ModifyWorkflowProperties)).void } + def modify_workflow_properties=(value) + end + + sig { void } + def clear_modify_workflow_properties + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::UpdateResponse)) } + def update_response + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::UpdateResponse)).void } + def update_response=(value) + end + + sig { void } + def clear_update_response + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleNexusOperation)) } + def schedule_nexus_operation + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleNexusOperation)).void } + def schedule_nexus_operation=(value) + end + + sig { void } + def clear_schedule_nexus_operation + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelNexusOperation)) } + def request_cancel_nexus_operation + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelNexusOperation)).void } + def request_cancel_nexus_operation=(value) + end + + sig { void } + def clear_request_cancel_nexus_operation + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Internal::Bridge::Api::WorkflowCommands::WorkflowCommand) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::WorkflowCommand).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::WorkflowCommand) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::WorkflowCommand, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::StartTimer + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + start_to_fire_timeout: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + seq: 0, + start_to_fire_timeout: nil + ) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number, used as the operation identifier + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { void } + def clear_seq + end + + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_fire_timeout + end + + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def start_to_fire_timeout=(value) + end + + sig { void } + def clear_start_to_fire_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::Internal::Bridge::Api::WorkflowCommands::StartTimer) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::StartTimer).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::StartTimer) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::StartTimer, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelTimer + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer) + ).void + end + def initialize( + seq: 0 + ) + end + + # Lang's incremental sequence number as passed to `StartTimer` + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number as passed to `StartTimer` + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number as passed to `StartTimer` + sig { void } + def clear_seq + 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::Internal::Bridge::Api::WorkflowCommands::CancelTimer) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelTimer).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelTimer) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelTimer, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleActivity + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + activity_id: T.nilable(String), + activity_type: T.nilable(String), + task_queue: T.nilable(String), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + arguments: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + heartbeat_timeout: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + cancellation_type: T.nilable(T.any(Symbol, String, Integer)), + do_not_eagerly_execute: T.nilable(T::Boolean), + versioning_intent: T.nilable(T.any(Symbol, String, Integer)), + priority: T.nilable(Temporalio::Api::Common::V1::Priority) + ).void + end + def initialize( + seq: 0, + activity_id: "", + activity_type: "", + task_queue: "", + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + arguments: [], + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + heartbeat_timeout: nil, + retry_policy: nil, + cancellation_type: :TRY_CANCEL, + do_not_eagerly_execute: false, + versioning_intent: :UNSPECIFIED, + priority: nil + ) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number, used as the operation identifier + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { void } + def clear_seq + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + sig { returns(String) } + def activity_type + end + + sig { params(value: String).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + end + + # The name of the task queue to place this activity request in + sig { returns(String) } + def task_queue + end + + # The name of the task queue to place this activity request in + sig { params(value: String).void } + def task_queue=(value) + end + + # The name of the task queue to place this activity request in + sig { void } + def clear_task_queue + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + sig { void } + def clear_headers + end + + # Arguments/input to the activity. Called "input" upstream. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def arguments + end + + # Arguments/input to the activity. Called "input" upstream. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def arguments=(value) + end + + # Arguments/input to the activity. Called "input" upstream. + sig { void } + def clear_arguments + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or start_to_close_timeout_seconds must be specified. +# When not specified defaults to the workflow execution timeout. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_close_timeout + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or start_to_close_timeout_seconds must be specified. +# When not specified defaults to the workflow execution timeout. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_close_timeout=(value) + end + + # Indicates how long the caller is willing to wait for an activity completion. Limits how long +# retries will be attempted. Either this or start_to_close_timeout_seconds must be specified. +# When not specified defaults to the workflow execution timeout. + sig { void } + def clear_schedule_to_close_timeout + end + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable as all a retry would achieve is to put it back into the same +# queue. Defaults to schedule_to_close_timeout or workflow execution timeout if not specified. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_start_timeout + end + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable as all a retry would achieve is to put it back into the same +# queue. Defaults to schedule_to_close_timeout or workflow execution timeout if not specified. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_start_timeout=(value) + end + + # Limits time an activity task can stay in a task queue before a worker picks it up. This +# timeout is always non retryable as all a retry would achieve is to put it back into the same +# queue. Defaults to schedule_to_close_timeout or workflow execution timeout if not specified. + sig { void } + def clear_schedule_to_start_timeout + end + + # Maximum time an activity is allowed to execute after a pick up by a worker. This timeout is +# always retryable. Either this or schedule_to_close_timeout must be specified. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Maximum time an activity is allowed to execute after a pick up by a worker. This timeout is +# always retryable. Either this or schedule_to_close_timeout must be specified. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def start_to_close_timeout=(value) + end + + # Maximum time an activity is allowed to execute after a pick up by a worker. This timeout is +# always retryable. Either this or schedule_to_close_timeout must be specified. + sig { void } + def clear_start_to_close_timeout + end + + # Maximum time allowed between successful worker heartbeats. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def heartbeat_timeout + end + + # Maximum time allowed between successful worker heartbeats. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def heartbeat_timeout=(value) + end + + # Maximum time allowed between successful worker heartbeats. + sig { void } + def clear_heartbeat_timeout + end + + # Activities are provided by a default retry policy controlled through the service dynamic +# configuration. Retries are happening up to schedule_to_close_timeout. To disable retries set +# retry_policy.maximum_attempts to 1. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # Activities are provided by a default retry policy controlled through the service dynamic +# configuration. Retries are happening up to schedule_to_close_timeout. To disable retries set +# retry_policy.maximum_attempts to 1. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # Activities are provided by a default retry policy controlled through the service dynamic +# configuration. Retries are happening up to schedule_to_close_timeout. To disable retries set +# retry_policy.maximum_attempts to 1. + sig { void } + def clear_retry_policy + end + + # Defines how the workflow will wait (or not) for cancellation of the activity to be confirmed + sig { returns(T.any(Symbol, Integer)) } + def cancellation_type + end + + # Defines how the workflow will wait (or not) for cancellation of the activity to be confirmed + sig { params(value: T.any(Symbol, String, Integer)).void } + def cancellation_type=(value) + end + + # Defines how the workflow will wait (or not) for cancellation of the activity to be confirmed + sig { void } + def clear_cancellation_type + end + + # If set, the worker will not tell the service that it can immediately start executing this +# activity. When unset/default, workers will always attempt to do so if activity execution +# slots are available. + sig { returns(T::Boolean) } + def do_not_eagerly_execute + end + + # If set, the worker will not tell the service that it can immediately start executing this +# activity. When unset/default, workers will always attempt to do so if activity execution +# slots are available. + sig { params(value: T::Boolean).void } + def do_not_eagerly_execute=(value) + end + + # If set, the worker will not tell the service that it can immediately start executing this +# activity. When unset/default, workers will always attempt to do so if activity execution +# slots are available. + sig { void } + def clear_do_not_eagerly_execute + end + + # Whether this activity should run on a worker with a compatible build id or not. + sig { returns(T.any(Symbol, Integer)) } + def versioning_intent + end + + # Whether this activity should run on a worker with a compatible build id or not. + sig { params(value: T.any(Symbol, String, Integer)).void } + def versioning_intent=(value) + end + + # Whether this activity should run on a worker with a compatible build id or not. + sig { void } + def clear_versioning_intent + end + + # The Priority to use for this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # The Priority to use for this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # The Priority to use for this activity + sig { void } + def clear_priority + 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::Internal::Bridge::Api::WorkflowCommands::ScheduleActivity) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleActivity).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleActivity) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleActivity, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleLocalActivity + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + activity_id: T.nilable(String), + activity_type: T.nilable(String), + attempt: T.nilable(Integer), + original_schedule_time: T.nilable(Google::Protobuf::Timestamp), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + arguments: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + local_retry_threshold: T.nilable(Google::Protobuf::Duration), + cancellation_type: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + seq: 0, + activity_id: "", + activity_type: "", + attempt: 0, + original_schedule_time: nil, + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + arguments: [], + schedule_to_close_timeout: nil, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil, + retry_policy: nil, + local_retry_threshold: nil, + cancellation_type: :TRY_CANCEL + ) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number, used as the operation identifier + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { void } + def clear_seq + end + + sig { returns(String) } + def activity_id + end + + sig { params(value: String).void } + def activity_id=(value) + end + + sig { void } + def clear_activity_id + end + + sig { returns(String) } + def activity_type + end + + sig { params(value: String).void } + def activity_type=(value) + end + + sig { void } + def clear_activity_type + end + + # Local activities can start with a non-1 attempt, if lang has been told to backoff using +# a timer before retrying. It should pass the attempt number from a `DoBackoff` activity +# resolution. + sig { returns(Integer) } + def attempt + end + + # Local activities can start with a non-1 attempt, if lang has been told to backoff using +# a timer before retrying. It should pass the attempt number from a `DoBackoff` activity +# resolution. + sig { params(value: Integer).void } + def attempt=(value) + end + + # Local activities can start with a non-1 attempt, if lang has been told to backoff using +# a timer before retrying. It should pass the attempt number from a `DoBackoff` activity +# resolution. + sig { void } + def clear_attempt + end + + # If this local activity is a retry (as per the attempt field) this needs to be the original +# scheduling time (as provided in `DoBackoff`) + sig { returns(T.nilable(Google::Protobuf::Timestamp)) } + def original_schedule_time + end + + # If this local activity is a retry (as per the attempt field) this needs to be the original +# scheduling time (as provided in `DoBackoff`) + sig { params(value: T.nilable(Google::Protobuf::Timestamp)).void } + def original_schedule_time=(value) + end + + # If this local activity is a retry (as per the attempt field) this needs to be the original +# scheduling time (as provided in `DoBackoff`) + sig { void } + def clear_original_schedule_time + end + + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + sig { void } + def clear_headers + end + + # Arguments/input to the activity. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def arguments + end + + # Arguments/input to the activity. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def arguments=(value) + end + + # Arguments/input to the activity. + sig { void } + def clear_arguments + end + + # Indicates how long the caller is willing to wait for local activity completion. Limits how +# long retries will be attempted. When not specified defaults to the workflow execution +# timeout (which may be unset). + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_close_timeout + end + + # Indicates how long the caller is willing to wait for local activity completion. Limits how +# long retries will be attempted. When not specified defaults to the workflow execution +# timeout (which may be unset). + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_close_timeout=(value) + end + + # Indicates how long the caller is willing to wait for local activity completion. Limits how +# long retries will be attempted. When not specified defaults to the workflow execution +# timeout (which may be unset). + sig { void } + def clear_schedule_to_close_timeout + end + + # Limits time the local activity can idle internally before being executed. That can happen if +# the worker is currently at max concurrent local activity executions. This timeout is always +# non retryable as all a retry would achieve is to put it back into the same queue. Defaults +# to `schedule_to_close_timeout` if not specified and that is set. Must be <= +# `schedule_to_close_timeout` when set, otherwise, it will be clamped down. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_start_timeout + end + + # Limits time the local activity can idle internally before being executed. That can happen if +# the worker is currently at max concurrent local activity executions. This timeout is always +# non retryable as all a retry would achieve is to put it back into the same queue. Defaults +# to `schedule_to_close_timeout` if not specified and that is set. Must be <= +# `schedule_to_close_timeout` when set, otherwise, it will be clamped down. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_start_timeout=(value) + end + + # Limits time the local activity can idle internally before being executed. That can happen if +# the worker is currently at max concurrent local activity executions. This timeout is always +# non retryable as all a retry would achieve is to put it back into the same queue. Defaults +# to `schedule_to_close_timeout` if not specified and that is set. Must be <= +# `schedule_to_close_timeout` when set, otherwise, it will be clamped down. + sig { void } + def clear_schedule_to_start_timeout + end + + # Maximum time the local activity is allowed to execute after the task is dispatched. This +# timeout is always retryable. Either or both of `schedule_to_close_timeout` and this must be +# specified. If set, this must be <= `schedule_to_close_timeout`, otherwise, it will be +# clamped down. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Maximum time the local activity is allowed to execute after the task is dispatched. This +# timeout is always retryable. Either or both of `schedule_to_close_timeout` and this must be +# specified. If set, this must be <= `schedule_to_close_timeout`, otherwise, it will be +# clamped down. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def start_to_close_timeout=(value) + end + + # Maximum time the local activity is allowed to execute after the task is dispatched. This +# timeout is always retryable. Either or both of `schedule_to_close_timeout` and this must be +# specified. If set, this must be <= `schedule_to_close_timeout`, otherwise, it will be +# clamped down. + sig { void } + def clear_start_to_close_timeout + end + + # Specify a retry policy for the local activity. By default local activities will be retried +# indefinitely. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # Specify a retry policy for the local activity. By default local activities will be retried +# indefinitely. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # Specify a retry policy for the local activity. By default local activities will be retried +# indefinitely. + sig { void } + def clear_retry_policy + end + + # If the activity is retrying and backoff would exceed this value, lang will be told to +# schedule a timer and retry the activity after. Otherwise, backoff will happen internally in +# core. Defaults to 1 minute. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def local_retry_threshold + end + + # If the activity is retrying and backoff would exceed this value, lang will be told to +# schedule a timer and retry the activity after. Otherwise, backoff will happen internally in +# core. Defaults to 1 minute. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def local_retry_threshold=(value) + end + + # If the activity is retrying and backoff would exceed this value, lang will be told to +# schedule a timer and retry the activity after. Otherwise, backoff will happen internally in +# core. Defaults to 1 minute. + sig { void } + def clear_local_retry_threshold + end + + # Defines how the workflow will wait (or not) for cancellation of the activity to be +# confirmed. Lang should default this to `WAIT_CANCELLATION_COMPLETED`, even though proto +# will default to `TRY_CANCEL` automatically. + sig { returns(T.any(Symbol, Integer)) } + def cancellation_type + end + + # Defines how the workflow will wait (or not) for cancellation of the activity to be +# confirmed. Lang should default this to `WAIT_CANCELLATION_COMPLETED`, even though proto +# will default to `TRY_CANCEL` automatically. + sig { params(value: T.any(Symbol, String, Integer)).void } + def cancellation_type=(value) + end + + # Defines how the workflow will wait (or not) for cancellation of the activity to be +# confirmed. Lang should default this to `WAIT_CANCELLATION_COMPLETED`, even though proto +# will default to `TRY_CANCEL` automatically. + sig { void } + def clear_cancellation_type + 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::Internal::Bridge::Api::WorkflowCommands::ScheduleLocalActivity) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleLocalActivity).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleLocalActivity) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleLocalActivity, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelActivity + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer) + ).void + end + def initialize( + seq: 0 + ) + end + + # Lang's incremental sequence number as passed to `ScheduleActivity` + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number as passed to `ScheduleActivity` + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number as passed to `ScheduleActivity` + sig { void } + def clear_seq + 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::Internal::Bridge::Api::WorkflowCommands::RequestCancelActivity) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelActivity).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelActivity) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelActivity, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelLocalActivity + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer) + ).void + end + def initialize( + seq: 0 + ) + end + + # Lang's incremental sequence number as passed to `ScheduleLocalActivity` + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number as passed to `ScheduleLocalActivity` + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number as passed to `ScheduleLocalActivity` + sig { void } + def clear_seq + 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::Internal::Bridge::Api::WorkflowCommands::RequestCancelLocalActivity) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelLocalActivity).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelLocalActivity) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelLocalActivity, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::QueryResult + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + query_id: T.nilable(String), + succeeded: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::QuerySuccess), + failed: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + query_id: "", + succeeded: nil, + failed: nil + ) + end + + # Corresponds to the id provided in the activation job + sig { returns(String) } + def query_id + end + + # Corresponds to the id provided in the activation job + sig { params(value: String).void } + def query_id=(value) + end + + # Corresponds to the id provided in the activation job + sig { void } + def clear_query_id + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::QuerySuccess)) } + def succeeded + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::QuerySuccess)).void } + def succeeded=(value) + end + + sig { void } + def clear_succeeded + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failed + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failed=(value) + end + + sig { void } + def clear_failed + end + + sig { returns(T.nilable(Symbol)) } + def variant + 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::Internal::Bridge::Api::WorkflowCommands::QueryResult) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::QueryResult).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::QueryResult) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::QueryResult, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::QuerySuccess + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + response: T.nilable(Temporalio::Api::Common::V1::Payload) + ).void + end + def initialize( + response: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def response + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def response=(value) + end + + sig { void } + def clear_response + 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::Internal::Bridge::Api::WorkflowCommands::QuerySuccess) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::QuerySuccess).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::QuerySuccess) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::QuerySuccess, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Issued when the workflow completes successfully +class Temporalio::Internal::Bridge::Api::WorkflowCommands::CompleteWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + result: T.nilable(Temporalio::Api::Common::V1::Payload) + ).void + end + def initialize( + result: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def result + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def result=(value) + end + + sig { void } + def clear_result + 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::Internal::Bridge::Api::WorkflowCommands::CompleteWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CompleteWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::CompleteWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CompleteWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Issued when the workflow errors out +class Temporalio::Internal::Bridge::Api::WorkflowCommands::FailWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure) + ).void + end + def initialize( + failure: nil + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + 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::Internal::Bridge::Api::WorkflowCommands::FailWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::FailWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::FailWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::FailWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Continue the workflow as a new execution +class Temporalio::Internal::Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + workflow_type: T.nilable(String), + task_queue: T.nilable(String), + arguments: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + memo: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + versioning_intent: T.nilable(T.any(Symbol, String, Integer)), + initial_versioning_behavior: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + workflow_type: "", + task_queue: "", + arguments: [], + workflow_run_timeout: nil, + workflow_task_timeout: nil, + memo: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + search_attributes: nil, + retry_policy: nil, + versioning_intent: :UNSPECIFIED, + initial_versioning_behavior: :CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_UNSPECIFIED + ) + end + + # The identifier the lang-specific sdk uses to execute workflow code + sig { returns(String) } + def workflow_type + end + + # The identifier the lang-specific sdk uses to execute workflow code + sig { params(value: String).void } + def workflow_type=(value) + end + + # The identifier the lang-specific sdk uses to execute workflow code + sig { void } + def clear_workflow_type + end + + # Task queue for the new workflow execution + sig { returns(String) } + def task_queue + end + + # Task queue for the new workflow execution + sig { params(value: String).void } + def task_queue=(value) + end + + # Task queue for the new workflow execution + sig { void } + def clear_task_queue + end + + # Inputs to the workflow code. Should be specified. Will not re-use old arguments, as that +# typically wouldn't make any sense. + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def arguments + end + + # Inputs to the workflow code. Should be specified. Will not re-use old arguments, as that +# typically wouldn't make any sense. + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def arguments=(value) + end + + # Inputs to the workflow code. Should be specified. Will not re-use old arguments, as that +# typically wouldn't make any sense. + sig { void } + def clear_arguments + end + + # Timeout for a single run of the new workflow. Will not re-use current workflow's value. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout for a single run of the new workflow. Will not re-use current workflow's value. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout for a single run of the new workflow. Will not re-use current workflow's value. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. Will not re-use current workflow's value. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. Will not re-use current workflow's value. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. Will not re-use current workflow's value. + sig { void } + def clear_workflow_task_timeout + end + + # If set, the new workflow will have this memo. If unset, re-uses the current workflow's memo + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def memo + end + + # If set, the new workflow will have this memo. If unset, re-uses the current workflow's memo + sig { params(value: ::Google::Protobuf::Map).void } + def memo=(value) + end + + # If set, the new workflow will have this memo. If unset, re-uses the current workflow's memo + sig { void } + def clear_memo + end + + # If set, the new workflow will have these headers. Will *not* re-use current workflow's +# headers otherwise. + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + # If set, the new workflow will have these headers. Will *not* re-use current workflow's +# headers otherwise. + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + # If set, the new workflow will have these headers. Will *not* re-use current workflow's +# headers otherwise. + sig { void } + def clear_headers + end + + # If set, the new workflow will have these search attributes. If unset, re-uses the current +# workflow's search attributes. + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # If set, the new workflow will have these search attributes. If unset, re-uses the current +# workflow's search attributes. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # If set, the new workflow will have these search attributes. If unset, re-uses the current +# workflow's search attributes. + sig { void } + def clear_search_attributes + end + + # If set, the new workflow will have this retry policy. If unset, re-uses the current +# workflow's retry policy. + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + # If set, the new workflow will have this retry policy. If unset, re-uses the current +# workflow's retry policy. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + # If set, the new workflow will have this retry policy. If unset, re-uses the current +# workflow's retry policy. + sig { void } + def clear_retry_policy + end + + # Whether the continued workflow should run on a worker with a compatible build id or not. + sig { returns(T.any(Symbol, Integer)) } + def versioning_intent + end + + # Whether the continued workflow should run on a worker with a compatible build id or not. + sig { params(value: T.any(Symbol, String, Integer)).void } + def versioning_intent=(value) + end + + # Whether the continued workflow should run on a worker with a compatible build id or not. + sig { void } + def clear_versioning_intent + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { returns(T.any(Symbol, Integer)) } + def initial_versioning_behavior + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { params(value: T.any(Symbol, String, Integer)).void } + def initial_versioning_behavior=(value) + end + + # Experimental. Optionally decide the versioning behavior that the first task of the new run should use. +# For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version +# of the previous run. + sig { void } + def clear_initial_versioning_behavior + 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::Internal::Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ContinueAsNewWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Indicate a workflow has completed as cancelled. Generally sent as a response to an activation +# containing a cancellation job. +class Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig {void} + def initialize; 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::Internal::Bridge::Api::WorkflowCommands::CancelWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A request to set/check if a certain patch is present or not +class Temporalio::Internal::Bridge::Api::WorkflowCommands::SetPatchMarker + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + patch_id: T.nilable(String), + deprecated: T.nilable(T::Boolean) + ).void + end + def initialize( + patch_id: "", + deprecated: false + ) + end + + # A user-chosen identifier for this patch. If the same identifier is used in multiple places in +# the code, those places are considered to be versioned as one unit. IE: The check call will +# return the same result for all of them + sig { returns(String) } + def patch_id + end + + # A user-chosen identifier for this patch. If the same identifier is used in multiple places in +# the code, those places are considered to be versioned as one unit. IE: The check call will +# return the same result for all of them + sig { params(value: String).void } + def patch_id=(value) + end + + # A user-chosen identifier for this patch. If the same identifier is used in multiple places in +# the code, those places are considered to be versioned as one unit. IE: The check call will +# return the same result for all of them + sig { void } + def clear_patch_id + end + + # Can be set to true to indicate that branches using this change are being removed, and all +# future worker deployments will only have the "with change" code in them. + sig { returns(T::Boolean) } + def deprecated + end + + # Can be set to true to indicate that branches using this change are being removed, and all +# future worker deployments will only have the "with change" code in them. + sig { params(value: T::Boolean).void } + def deprecated=(value) + end + + # Can be set to true to indicate that branches using this change are being removed, and all +# future worker deployments will only have the "with change" code in them. + sig { void } + def clear_deprecated + 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::Internal::Bridge::Api::WorkflowCommands::SetPatchMarker) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::SetPatchMarker).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::SetPatchMarker) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::SetPatchMarker, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Start a child workflow execution +class Temporalio::Internal::Bridge::Api::WorkflowCommands::StartChildWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + namespace: T.nilable(String), + workflow_id: T.nilable(String), + workflow_type: T.nilable(String), + task_queue: T.nilable(String), + input: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + workflow_execution_timeout: T.nilable(Google::Protobuf::Duration), + workflow_run_timeout: T.nilable(Google::Protobuf::Duration), + workflow_task_timeout: T.nilable(Google::Protobuf::Duration), + parent_close_policy: T.nilable(T.any(Symbol, String, Integer)), + workflow_id_reuse_policy: T.nilable(T.any(Symbol, String, Integer)), + retry_policy: T.nilable(Temporalio::Api::Common::V1::RetryPolicy), + cron_schedule: T.nilable(String), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + memo: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]), + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes), + cancellation_type: T.nilable(T.any(Symbol, String, Integer)), + versioning_intent: T.nilable(T.any(Symbol, String, Integer)), + priority: T.nilable(Temporalio::Api::Common::V1::Priority) + ).void + end + def initialize( + seq: 0, + namespace: "", + workflow_id: "", + workflow_type: "", + task_queue: "", + input: [], + workflow_execution_timeout: nil, + workflow_run_timeout: nil, + workflow_task_timeout: nil, + parent_close_policy: :PARENT_CLOSE_POLICY_UNSPECIFIED, + workflow_id_reuse_policy: :WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED, + retry_policy: nil, + cron_schedule: "", + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + memo: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload), + search_attributes: nil, + cancellation_type: :ABANDON, + versioning_intent: :UNSPECIFIED, + priority: nil + ) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number, used as the operation identifier + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { void } + def clear_seq + end + + sig { returns(String) } + def namespace + end + + sig { params(value: String).void } + def namespace=(value) + end + + sig { void } + def clear_namespace + end + + sig { returns(String) } + def workflow_id + end + + sig { params(value: String).void } + def workflow_id=(value) + end + + sig { void } + def clear_workflow_id + end + + sig { returns(String) } + def workflow_type + end + + sig { params(value: String).void } + def workflow_type=(value) + end + + sig { void } + def clear_workflow_type + 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 + + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def input + end + + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def input=(value) + end + + sig { void } + def clear_input + end + + # Total workflow execution timeout including retries and continue as new. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_execution_timeout + end + + # Total workflow execution timeout including retries and continue as new. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_execution_timeout=(value) + end + + # Total workflow execution timeout including retries and continue as new. + sig { void } + def clear_workflow_execution_timeout + end + + # Timeout of a single workflow run. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_run_timeout + end + + # Timeout of a single workflow run. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_run_timeout=(value) + end + + # Timeout of a single workflow run. + sig { void } + def clear_workflow_run_timeout + end + + # Timeout of a single workflow task. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def workflow_task_timeout + end + + # Timeout of a single workflow task. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def workflow_task_timeout=(value) + end + + # Timeout of a single workflow task. + sig { void } + def clear_workflow_task_timeout + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { returns(T.any(Symbol, Integer)) } + def parent_close_policy + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def parent_close_policy=(value) + end + + # Default: PARENT_CLOSE_POLICY_TERMINATE. + sig { void } + def clear_parent_close_policy + end + + # string control = 11; (unused from StartChildWorkflowExecutionCommandAttributes) +# Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { returns(T.any(Symbol, Integer)) } + def workflow_id_reuse_policy + end + + # string control = 11; (unused from StartChildWorkflowExecutionCommandAttributes) +# Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { params(value: T.any(Symbol, String, Integer)).void } + def workflow_id_reuse_policy=(value) + end + + # string control = 11; (unused from StartChildWorkflowExecutionCommandAttributes) +# Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE. + sig { void } + def clear_workflow_id_reuse_policy + end + + sig { returns(T.nilable(Temporalio::Api::Common::V1::RetryPolicy)) } + def retry_policy + end + + sig { params(value: T.nilable(Temporalio::Api::Common::V1::RetryPolicy)).void } + def retry_policy=(value) + end + + sig { void } + def clear_retry_policy + end + + sig { returns(String) } + def cron_schedule + end + + sig { params(value: String).void } + def cron_schedule=(value) + end + + sig { void } + def clear_cron_schedule + end + + # Header fields + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + # Header fields + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + # Header fields + sig { void } + def clear_headers + end + + # Memo fields + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def memo + end + + # Memo fields + sig { params(value: ::Google::Protobuf::Map).void } + def memo=(value) + end + + # Memo fields + sig { void } + def clear_memo + end + + # Search attributes + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # Search attributes + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # Search attributes + sig { void } + def clear_search_attributes + end + + # Defines behaviour of the underlying workflow when child workflow cancellation has been requested. + sig { returns(T.any(Symbol, Integer)) } + def cancellation_type + end + + # Defines behaviour of the underlying workflow when child workflow cancellation has been requested. + sig { params(value: T.any(Symbol, String, Integer)).void } + def cancellation_type=(value) + end + + # Defines behaviour of the underlying workflow when child workflow cancellation has been requested. + sig { void } + def clear_cancellation_type + end + + # Whether this child should run on a worker with a compatible build id or not. + sig { returns(T.any(Symbol, Integer)) } + def versioning_intent + end + + # Whether this child should run on a worker with a compatible build id or not. + sig { params(value: T.any(Symbol, String, Integer)).void } + def versioning_intent=(value) + end + + # Whether this child should run on a worker with a compatible build id or not. + sig { void } + def clear_versioning_intent + end + + # The Priority to use for this activity + sig { returns(T.nilable(Temporalio::Api::Common::V1::Priority)) } + def priority + end + + # The Priority to use for this activity + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Priority)).void } + def priority=(value) + end + + # The Priority to use for this activity + sig { void } + def clear_priority + 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::Internal::Bridge::Api::WorkflowCommands::StartChildWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::StartChildWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::StartChildWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::StartChildWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Cancel a child workflow +class Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelChildWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + child_workflow_seq: T.nilable(Integer), + reason: T.nilable(String) + ).void + end + def initialize( + child_workflow_seq: 0, + reason: "" + ) + end + + # Sequence number as given to the `StartChildWorkflowExecution` command + sig { returns(Integer) } + def child_workflow_seq + end + + # Sequence number as given to the `StartChildWorkflowExecution` command + sig { params(value: Integer).void } + def child_workflow_seq=(value) + end + + # Sequence number as given to the `StartChildWorkflowExecution` command + sig { void } + def clear_child_workflow_seq + end + + # A reason for the cancellation + sig { returns(String) } + def reason + end + + # A reason for the cancellation + sig { params(value: String).void } + def reason=(value) + end + + # A reason for the cancellation + sig { void } + def clear_reason + 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::Internal::Bridge::Api::WorkflowCommands::CancelChildWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelChildWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelChildWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelChildWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Request cancellation of an external workflow execution. For cancellation of a child workflow, +# prefer `CancelChildWorkflowExecution` instead, as it guards against cancel-before-start issues. +class Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelExternalWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution), + reason: T.nilable(String) + ).void + end + def initialize( + seq: 0, + workflow_execution: nil, + reason: "" + ) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number, used as the operation identifier + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { void } + def clear_seq + end + + # The workflow instance being targeted + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution)) } + def workflow_execution + end + + # The workflow instance being targeted + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution)).void } + def workflow_execution=(value) + end + + # The workflow instance being targeted + sig { void } + def clear_workflow_execution + end + + # A reason for the cancellation + sig { returns(String) } + def reason + end + + # A reason for the cancellation + sig { params(value: String).void } + def reason=(value) + end + + # A reason for the cancellation + sig { void } + def clear_reason + 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::Internal::Bridge::Api::WorkflowCommands::RequestCancelExternalWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelExternalWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelExternalWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelExternalWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Send a signal to an external or child workflow +class Temporalio::Internal::Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + workflow_execution: T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution), + child_workflow_id: T.nilable(String), + signal_name: T.nilable(String), + args: T.nilable(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]), + headers: T.nilable(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) + ).void + end + def initialize( + seq: 0, + workflow_execution: nil, + child_workflow_id: "", + signal_name: "", + args: [], + headers: ::Google::Protobuf::Map.new(:string, :message, Temporalio::Api::Common::V1::Payload) + ) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number, used as the operation identifier + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { void } + def clear_seq + end + + # A specific workflow instance + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution)) } + def workflow_execution + end + + # A specific workflow instance + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::Common::NamespacedWorkflowExecution)).void } + def workflow_execution=(value) + end + + # A specific workflow instance + sig { void } + def clear_workflow_execution + end + + # The desired target must be a child of the issuing workflow, and this is its workflow id + sig { returns(String) } + def child_workflow_id + end + + # The desired target must be a child of the issuing workflow, and this is its workflow id + sig { params(value: String).void } + def child_workflow_id=(value) + end + + # The desired target must be a child of the issuing workflow, and this is its workflow id + sig { void } + def clear_child_workflow_id + end + + # Name of the signal handler + sig { returns(String) } + def signal_name + end + + # Name of the signal handler + sig { params(value: String).void } + def signal_name=(value) + end + + # Name of the signal handler + sig { void } + def clear_signal_name + end + + # Arguments for the handler + sig { returns(T::Array[T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def args + end + + # Arguments for the handler + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def args=(value) + end + + # Arguments for the handler + sig { void } + def clear_args + end + + # Headers to attach to the signal + sig { returns(T::Hash[String, T.nilable(Temporalio::Api::Common::V1::Payload)]) } + def headers + end + + # Headers to attach to the signal + sig { params(value: ::Google::Protobuf::Map).void } + def headers=(value) + end + + # Headers to attach to the signal + sig { void } + def clear_headers + end + + sig { returns(T.nilable(Symbol)) } + def target + 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::Internal::Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::SignalExternalWorkflowExecution, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Can be used to cancel not-already-sent `SignalExternalWorkflowExecution` commands +class Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelSignalWorkflow + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer) + ).void + end + def initialize( + seq: 0 + ) + end + + # Lang's incremental sequence number as passed to `SignalExternalWorkflowExecution` + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number as passed to `SignalExternalWorkflowExecution` + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number as passed to `SignalExternalWorkflowExecution` + sig { void } + def clear_seq + 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::Internal::Bridge::Api::WorkflowCommands::CancelSignalWorkflow) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelSignalWorkflow).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelSignalWorkflow) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::CancelSignalWorkflow, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes) + ).void + end + def initialize( + search_attributes: nil + ) + end + + # SearchAttributes to upsert. The indexed_fields map will be merged with existing search +# attributes, with these values taking precedence. + sig { returns(T.nilable(Temporalio::Api::Common::V1::SearchAttributes)) } + def search_attributes + end + + # SearchAttributes to upsert. The indexed_fields map will be merged with existing search +# attributes, with these values taking precedence. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def search_attributes=(value) + end + + # SearchAttributes to upsert. The indexed_fields map will be merged with existing search +# attributes, with these values taking precedence. + sig { void } + def clear_search_attributes + 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::Internal::Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::UpsertWorkflowSearchAttributes, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +class Temporalio::Internal::Bridge::Api::WorkflowCommands::ModifyWorkflowProperties + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + upserted_memo: T.nilable(Temporalio::Api::Common::V1::Memo) + ).void + end + def initialize( + upserted_memo: nil + ) + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Memo)) } + def upserted_memo + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Memo)).void } + def upserted_memo=(value) + end + + # If set, update the workflow memo with the provided values. The values will be merged with +# the existing memo. If the user wants to delete values, a default/empty Payload should be +# used as the value for the key being deleted. + sig { void } + def clear_upserted_memo + 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::Internal::Bridge::Api::WorkflowCommands::ModifyWorkflowProperties) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ModifyWorkflowProperties).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::ModifyWorkflowProperties) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ModifyWorkflowProperties, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A reply to a `DoUpdate` job - lang must run the update's validator if told to, and then +# immediately run the handler, if the update was accepted. +# +# There must always be an accepted or rejected response immediately, in the same activation as +# this job, to indicate the result of the validator. Accepted for ran and accepted or skipped, or +# rejected for rejected. +# +# Then, in the same or any subsequent activation, after the update handler has completed, respond +# with completed or rejected as appropriate for the result of the handler. +class Temporalio::Internal::Bridge::Api::WorkflowCommands::UpdateResponse + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + protocol_instance_id: T.nilable(String), + accepted: T.nilable(Google::Protobuf::Empty), + rejected: T.nilable(Temporalio::Api::Failure::V1::Failure), + completed: T.nilable(Temporalio::Api::Common::V1::Payload) + ).void + end + def initialize( + protocol_instance_id: "", + accepted: nil, + rejected: nil, + completed: nil + ) + end + + # The protocol message instance ID + sig { returns(String) } + def protocol_instance_id + end + + # The protocol message instance ID + sig { params(value: String).void } + def protocol_instance_id=(value) + end + + # The protocol message instance ID + sig { void } + def clear_protocol_instance_id + end + + # Must be sent if the update's validator has passed (or lang was not asked to run it, and +# thus should be considered already-accepted, allowing lang to always send the same +# sequence on replay). + sig { returns(T.nilable(Google::Protobuf::Empty)) } + def accepted + end + + # Must be sent if the update's validator has passed (or lang was not asked to run it, and +# thus should be considered already-accepted, allowing lang to always send the same +# sequence on replay). + sig { params(value: T.nilable(Google::Protobuf::Empty)).void } + def accepted=(value) + end + + # Must be sent if the update's validator has passed (or lang was not asked to run it, and +# thus should be considered already-accepted, allowing lang to always send the same +# sequence on replay). + sig { void } + def clear_accepted + end + + # Must be sent if the update's validator does not pass, or after acceptance if the update +# handler fails. + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def rejected + end + + # Must be sent if the update's validator does not pass, or after acceptance if the update +# handler fails. + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def rejected=(value) + end + + # Must be sent if the update's validator does not pass, or after acceptance if the update +# handler fails. + sig { void } + def clear_rejected + end + + # Must be sent once the update handler completes successfully. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def completed + end + + # Must be sent once the update handler completes successfully. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def completed=(value) + end + + # Must be sent once the update handler completes successfully. + sig { void } + def clear_completed + end + + sig { returns(T.nilable(Symbol)) } + def response + 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::Internal::Bridge::Api::WorkflowCommands::UpdateResponse) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::UpdateResponse).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::UpdateResponse) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::UpdateResponse, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# A request to begin a Nexus operation +class Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleNexusOperation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer), + endpoint: T.nilable(String), + service: T.nilable(String), + operation: T.nilable(String), + input: T.nilable(Temporalio::Api::Common::V1::Payload), + schedule_to_close_timeout: T.nilable(Google::Protobuf::Duration), + nexus_header: T.nilable(T::Hash[String, String]), + cancellation_type: T.nilable(T.any(Symbol, String, Integer)), + schedule_to_start_timeout: T.nilable(Google::Protobuf::Duration), + start_to_close_timeout: T.nilable(Google::Protobuf::Duration) + ).void + end + def initialize( + seq: 0, + endpoint: "", + service: "", + operation: "", + input: nil, + schedule_to_close_timeout: nil, + nexus_header: ::Google::Protobuf::Map.new(:string, :string), + cancellation_type: :WAIT_CANCELLATION_COMPLETED, + schedule_to_start_timeout: nil, + start_to_close_timeout: nil + ) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number, used as the operation identifier + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number, used as the operation identifier + sig { void } + def clear_seq + end + + # Endpoint name, must exist in the endpoint registry or this command will fail. + sig { returns(String) } + def endpoint + end + + # Endpoint name, must exist in the endpoint registry or this command will fail. + sig { params(value: String).void } + def endpoint=(value) + end + + # Endpoint name, must exist in the endpoint registry or this command will fail. + sig { void } + def clear_endpoint + end + + # Service name. + sig { returns(String) } + def service + end + + # Service name. + sig { params(value: String).void } + def service=(value) + end + + # Service name. + sig { void } + def clear_service + end + + # Operation name. + sig { returns(String) } + def operation + end + + # Operation name. + sig { params(value: String).void } + def operation=(value) + end + + # Operation name. + sig { void } + def clear_operation + end + + # Input for the operation. The server converts this into Nexus request content and the +# appropriate content headers internally when sending the StartOperation request. On the +# handler side, if it is also backed by Temporal, the content is transformed back to the +# original Payload sent in this command. + sig { returns(T.nilable(Temporalio::Api::Common::V1::Payload)) } + def input + end + + # Input for the operation. The server converts this into Nexus request content and the +# appropriate content headers internally when sending the StartOperation request. On the +# handler side, if it is also backed by Temporal, the content is transformed back to the +# original Payload sent in this command. + sig { params(value: T.nilable(Temporalio::Api::Common::V1::Payload)).void } + def input=(value) + end + + # Input for the operation. The server converts this into Nexus request content and the +# appropriate content headers internally when sending the StartOperation request. On the +# handler side, if it is also backed by Temporal, the content is transformed back to the +# original Payload sent in this command. + sig { void } + def clear_input + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_close_timeout + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_close_timeout=(value) + end + + # Schedule-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for operation completion. +# Calls are retried internally by the server. + sig { void } + def clear_schedule_to_close_timeout + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in +# workflow history and transmitted to external services as-is. This is useful for propagating +# tracing information. Note these headers are not the same as Temporal headers on internal +# activities and child workflows, these are transmitted to Nexus operations that may be +# external and are not traditional payloads. + sig { returns(T::Hash[String, String]) } + def nexus_header + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in +# workflow history and transmitted to external services as-is. This is useful for propagating +# tracing information. Note these headers are not the same as Temporal headers on internal +# activities and child workflows, these are transmitted to Nexus operations that may be +# external and are not traditional payloads. + sig { params(value: ::Google::Protobuf::Map).void } + def nexus_header=(value) + end + + # Header to attach to the Nexus request. +# Users are responsible for encrypting sensitive data in this header as it is stored in +# workflow history and transmitted to external services as-is. This is useful for propagating +# tracing information. Note these headers are not the same as Temporal headers on internal +# activities and child workflows, these are transmitted to Nexus operations that may be +# external and are not traditional payloads. + sig { void } + def clear_nexus_header + end + + # Defines behaviour of the underlying nexus operation when operation cancellation has been requested. + sig { returns(T.any(Symbol, Integer)) } + def cancellation_type + end + + # Defines behaviour of the underlying nexus operation when operation cancellation has been requested. + sig { params(value: T.any(Symbol, String, Integer)).void } + def cancellation_type=(value) + end + + # Defines behaviour of the underlying nexus operation when operation cancellation has been requested. + sig { void } + def clear_cancellation_type + end + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. If the operation is not started within this timeout, it will fail with +# TIMEOUT_TYPE_SCHEDULE_TO_START. +# If not set or zero, no schedule-to-start timeout is enforced. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def schedule_to_start_timeout + end + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. If the operation is not started within this timeout, it will fail with +# TIMEOUT_TYPE_SCHEDULE_TO_START. +# If not set or zero, no schedule-to-start timeout is enforced. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def schedule_to_start_timeout=(value) + end + + # Schedule-to-start timeout for this operation. +# Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous) +# by the handler. If the operation is not started within this timeout, it will fail with +# TIMEOUT_TYPE_SCHEDULE_TO_START. +# If not set or zero, no schedule-to-start timeout is enforced. + sig { void } + def clear_schedule_to_start_timeout + end + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. If the operation does not complete within this timeout after starting, it will fail with +# TIMEOUT_TYPE_START_TO_CLOSE. +# Only applies to asynchronous operations. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. + sig { returns(T.nilable(Google::Protobuf::Duration)) } + def start_to_close_timeout + end + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. If the operation does not complete within this timeout after starting, it will fail with +# TIMEOUT_TYPE_START_TO_CLOSE. +# Only applies to asynchronous operations. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. + sig { params(value: T.nilable(Google::Protobuf::Duration)).void } + def start_to_close_timeout=(value) + end + + # Start-to-close timeout for this operation. +# Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been +# started. If the operation does not complete within this timeout after starting, it will fail with +# TIMEOUT_TYPE_START_TO_CLOSE. +# Only applies to asynchronous operations. Synchronous operations ignore this timeout. +# If not set or zero, no start-to-close timeout is enforced. + sig { void } + def clear_start_to_close_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::Internal::Bridge::Api::WorkflowCommands::ScheduleNexusOperation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleNexusOperation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleNexusOperation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::ScheduleNexusOperation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Request cancellation of a nexus operation started via `ScheduleNexusOperation` +class Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelNexusOperation + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + seq: T.nilable(Integer) + ).void + end + def initialize( + seq: 0 + ) + end + + # Lang's incremental sequence number as passed to `ScheduleNexusOperation` + sig { returns(Integer) } + def seq + end + + # Lang's incremental sequence number as passed to `ScheduleNexusOperation` + sig { params(value: Integer).void } + def seq=(value) + end + + # Lang's incremental sequence number as passed to `ScheduleNexusOperation` + sig { void } + def clear_seq + 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::Internal::Bridge::Api::WorkflowCommands::RequestCancelNexusOperation) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelNexusOperation).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelNexusOperation) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCommands::RequestCancelNexusOperation, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +module Temporalio::Internal::Bridge::Api::WorkflowCommands::ActivityCancellationType + self::TRY_CANCEL = T.let(0, Integer) + self::WAIT_CANCELLATION_COMPLETED = T.let(1, Integer) + self::ABANDON = T.let(2, Integer) + + sig { params(value: Integer).returns(T.nilable(Symbol)) } + def self.lookup(value) + end + + sig { params(value: Symbol).returns(T.nilable(Integer)) } + def self.resolve(value) + end + + sig { returns(::Google::Protobuf::EnumDescriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/api/workflow_completion/workflow_completion.rbi b/temporalio/rbi/temporalio/internal/bridge/api/workflow_completion/workflow_completion.rbi new file mode 100644 index 00000000..c7d07d43 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/api/workflow_completion/workflow_completion.rbi @@ -0,0 +1,272 @@ +# Code generated by protoc-gen-rbi. DO NOT EDIT. +# source: temporal/sdk/core/workflow_completion/workflow_completion.proto +# typed: strict + +# Result of a single workflow activation, reported from lang to core +class Temporalio::Internal::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + run_id: T.nilable(String), + successful: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Success), + failed: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure) + ).void + end + def initialize( + run_id: "", + successful: nil, + failed: nil + ) + end + + # The run id from the workflow activation you are completing + sig { returns(String) } + def run_id + end + + # The run id from the workflow activation you are completing + sig { params(value: String).void } + def run_id=(value) + end + + # The run id from the workflow activation you are completing + sig { void } + def clear_run_id + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Success)) } + def successful + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Success)).void } + def successful=(value) + end + + sig { void } + def clear_successful + end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure)) } + def failed + end + + sig { params(value: T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure)).void } + def failed=(value) + end + + sig { void } + def clear_failed + end + + sig { returns(T.nilable(Symbol)) } + def status + 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::Internal::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Successful workflow activation with a list of commands generated by the workflow execution +class Temporalio::Internal::Bridge::Api::WorkflowCompletion::Success + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + commands: T.nilable(T::Array[T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::WorkflowCommand)]), + used_internal_flags: T.nilable(T::Array[Integer]), + versioning_behavior: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + commands: [], + used_internal_flags: [], + versioning_behavior: :VERSIONING_BEHAVIOR_UNSPECIFIED + ) + end + + # A list of commands to send back to the temporal server + sig { returns(T::Array[T.nilable(Temporalio::Internal::Bridge::Api::WorkflowCommands::WorkflowCommand)]) } + def commands + end + + # A list of commands to send back to the temporal server + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def commands=(value) + end + + # A list of commands to send back to the temporal server + sig { void } + def clear_commands + end + + # Any internal flags which the lang SDK used in the processing of this activation + sig { returns(T::Array[Integer]) } + def used_internal_flags + end + + # Any internal flags which the lang SDK used in the processing of this activation + sig { params(value: ::Google::Protobuf::RepeatedField).void } + def used_internal_flags=(value) + end + + # Any internal flags which the lang SDK used in the processing of this activation + sig { void } + def clear_used_internal_flags + end + + # The versioning behavior this workflow is currently using + sig { returns(T.any(Symbol, Integer)) } + def versioning_behavior + end + + # The versioning behavior this workflow is currently using + sig { params(value: T.any(Symbol, String, Integer)).void } + def versioning_behavior=(value) + end + + # The versioning behavior this workflow is currently using + sig { void } + def clear_versioning_behavior + 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::Internal::Bridge::Api::WorkflowCompletion::Success) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCompletion::Success).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Success) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCompletion::Success, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end + +# Failure to activate or execute a workflow +class Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure + include ::Google::Protobuf::MessageExts + extend ::Google::Protobuf::MessageExts::ClassMethods + + sig do + params( + failure: T.nilable(Temporalio::Api::Failure::V1::Failure), + force_cause: T.nilable(T.any(Symbol, String, Integer)) + ).void + end + def initialize( + failure: nil, + force_cause: :WORKFLOW_TASK_FAILED_CAUSE_UNSPECIFIED + ) + end + + sig { returns(T.nilable(Temporalio::Api::Failure::V1::Failure)) } + def failure + end + + sig { params(value: T.nilable(Temporalio::Api::Failure::V1::Failure)).void } + def failure=(value) + end + + sig { void } + def clear_failure + end + + # Forces overriding the WFT failure cause + sig { returns(T.any(Symbol, Integer)) } + def force_cause + end + + # Forces overriding the WFT failure cause + sig { params(value: T.any(Symbol, String, Integer)).void } + def force_cause=(value) + end + + # Forces overriding the WFT failure cause + sig { void } + def clear_force_cause + 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::Internal::Bridge::Api::WorkflowCompletion::Failure) } + def self.decode(str) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure).returns(String) } + def self.encode(msg) + end + + sig { params(str: String, kw: T.untyped).returns(Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure) } + def self.decode_json(str, **kw) + end + + sig { params(msg: Temporalio::Internal::Bridge::Api::WorkflowCompletion::Failure, kw: T.untyped).returns(String) } + def self.encode_json(msg, **kw) + end + + sig { returns(::Google::Protobuf::Descriptor) } + def self.descriptor + end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/client.rbi b/temporalio/rbi/temporalio/internal/bridge/client.rbi new file mode 100644 index 00000000..fe28e749 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/client.rbi @@ -0,0 +1,331 @@ +# typed: true + +class Temporalio::Internal::Bridge::Client + extend T::Sig + + SERVICE_WORKFLOW = T.let(T.unsafe(nil), Integer) + SERVICE_OPERATOR = T.let(T.unsafe(nil), Integer) + SERVICE_CLOUD = T.let(T.unsafe(nil), Integer) + SERVICE_TEST = T.let(T.unsafe(nil), Integer) + SERVICE_HEALTH = T.let(T.unsafe(nil), Integer) + + sig do + params( + runtime: Temporalio::Internal::Bridge::Runtime, + options: Temporalio::Internal::Bridge::Client::Options + ).returns(Temporalio::Internal::Bridge::Client) + end + def self.new(runtime, options); end + + sig do + params( + runtime: Temporalio::Internal::Bridge::Runtime, + options: Temporalio::Internal::Bridge::Client::Options, + queue: Queue + ).void + end + def self.async_new(runtime, options, queue); end + + sig do + params( + service: Integer, + rpc: String, + request: String, + rpc_retry: T::Boolean, + rpc_metadata: T.nilable(T::Hash[String, String]), + rpc_timeout: T.nilable(T.any(Integer, Float)), + rpc_cancellation_token: T.nilable(Temporalio::Internal::Bridge::Client::CancellationToken), + queue: Queue + ).void + end + def async_invoke_rpc( + service:, + rpc:, + request:, + rpc_retry:, + rpc_metadata:, + rpc_timeout:, + rpc_cancellation_token:, + queue: + ); end + + sig { params(rpc_metadata: T::Hash[String, String]).void } + def update_metadata(rpc_metadata); end + + sig { params(api_key: T.nilable(String)).void } + def update_api_key(api_key); end +end + +class Temporalio::Internal::Bridge::Client::Options < ::Struct + extend T::Sig + + sig do + params( + target_host: String, + client_name: String, + client_version: String, + rpc_metadata: T::Hash[String, String], + api_key: T.nilable(String), + identity: String, + tls: T.nilable(Temporalio::Internal::Bridge::Client::TLSOptions), + rpc_retry: Temporalio::Internal::Bridge::Client::RPCRetryOptions, + keep_alive: T.nilable(Temporalio::Internal::Bridge::Client::KeepAliveOptions), + http_connect_proxy: T.nilable(Temporalio::Internal::Bridge::Client::HTTPConnectProxyOptions), + dns_load_balancing: T.nilable(Temporalio::Internal::Bridge::Client::DnsLoadBalancingOptions) + ).void + end + def initialize( + target_host, + client_name, + client_version, + rpc_metadata, + api_key, + identity, + tls, + rpc_retry, + keep_alive, + http_connect_proxy, + dns_load_balancing + ); end + + sig { returns(String) } + def target_host; end + + sig { params(_: String).void } + def target_host=(_); end + + sig { returns(String) } + def client_name; end + + sig { params(_: String).void } + def client_name=(_); end + + sig { returns(String) } + def client_version; end + + sig { params(_: String).void } + def client_version=(_); end + + sig { returns(T::Hash[String, String]) } + def rpc_metadata; end + + sig { params(_: T::Hash[String, String]).void } + def rpc_metadata=(_); end + + sig { returns(T.nilable(String)) } + def api_key; end + + sig { params(_: T.nilable(String)).void } + def api_key=(_); end + + sig { returns(String) } + def identity; end + + sig { params(_: String).void } + def identity=(_); end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Client::TLSOptions)) } + def tls; end + + sig { params(_: T.nilable(Temporalio::Internal::Bridge::Client::TLSOptions)).void } + def tls=(_); end + + sig { returns(Temporalio::Internal::Bridge::Client::RPCRetryOptions) } + def rpc_retry; end + + sig { params(_: Temporalio::Internal::Bridge::Client::RPCRetryOptions).void } + def rpc_retry=(_); end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Client::KeepAliveOptions)) } + def keep_alive; end + + sig { params(_: T.nilable(Temporalio::Internal::Bridge::Client::KeepAliveOptions)).void } + def keep_alive=(_); end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Client::HTTPConnectProxyOptions)) } + def http_connect_proxy; end + + sig { params(_: T.nilable(Temporalio::Internal::Bridge::Client::HTTPConnectProxyOptions)).void } + def http_connect_proxy=(_); end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Client::DnsLoadBalancingOptions)) } + def dns_load_balancing; end + + sig { params(_: T.nilable(Temporalio::Internal::Bridge::Client::DnsLoadBalancingOptions)).void } + def dns_load_balancing=(_); end +end + +class Temporalio::Internal::Bridge::Client::TLSOptions < ::Struct + extend T::Sig + + sig do + params( + client_cert: T.nilable(String), + client_private_key: T.nilable(String), + server_root_ca_cert: T.nilable(String), + domain: T.nilable(String) + ).void + end + def initialize( + client_cert = T.unsafe(nil), + client_private_key = T.unsafe(nil), + server_root_ca_cert = T.unsafe(nil), + domain = T.unsafe(nil) + ); end + + sig { returns(T.nilable(String)) } + def client_cert; end + + sig { params(_: T.nilable(String)).void } + def client_cert=(_); end + + sig { returns(T.nilable(String)) } + def client_private_key; end + + sig { params(_: T.nilable(String)).void } + def client_private_key=(_); end + + sig { returns(T.nilable(String)) } + def server_root_ca_cert; end + + sig { params(_: T.nilable(String)).void } + def server_root_ca_cert=(_); end + + sig { returns(T.nilable(String)) } + def domain; end + + sig { params(_: T.nilable(String)).void } + def domain=(_); end +end + +class Temporalio::Internal::Bridge::Client::RPCRetryOptions < ::Struct + extend T::Sig + + sig do + params( + initial_interval: T.any(Integer, Float), + randomization_factor: T.any(Integer, Float), + multiplier: T.any(Integer, Float), + max_interval: T.any(Integer, Float), + max_elapsed_time: T.any(Integer, Float), + max_retries: Integer + ).void + end + def initialize(initial_interval, randomization_factor, multiplier, max_interval, max_elapsed_time, max_retries); end + + sig { returns(T.any(Integer, Float)) } + def initial_interval; end + + sig { params(_: T.any(Integer, Float)).void } + def initial_interval=(_); end + + sig { returns(T.any(Integer, Float)) } + def randomization_factor; end + + sig { params(_: T.any(Integer, Float)).void } + def randomization_factor=(_); end + + sig { returns(T.any(Integer, Float)) } + def multiplier; end + + sig { params(_: T.any(Integer, Float)).void } + def multiplier=(_); end + + sig { returns(T.any(Integer, Float)) } + def max_interval; end + + sig { params(_: T.any(Integer, Float)).void } + def max_interval=(_); end + + sig { returns(T.any(Integer, Float)) } + def max_elapsed_time; end + + sig { params(_: T.any(Integer, Float)).void } + def max_elapsed_time=(_); end + + sig { returns(Integer) } + def max_retries; end + + sig { params(_: Integer).void } + def max_retries=(_); end +end + +class Temporalio::Internal::Bridge::Client::KeepAliveOptions < ::Struct + extend T::Sig + + sig { params(interval: T.any(Integer, Float), timeout: T.any(Integer, Float)).void } + def initialize(interval, timeout); end + + sig { returns(T.any(Integer, Float)) } + def interval; end + + sig { params(_: T.any(Integer, Float)).void } + def interval=(_); end + + sig { returns(T.any(Integer, Float)) } + def timeout; end + + sig { params(_: T.any(Integer, Float)).void } + def timeout=(_); end +end + +class Temporalio::Internal::Bridge::Client::HTTPConnectProxyOptions < ::Struct + extend T::Sig + + sig { params(target_host: String, basic_auth_user: T.nilable(String), basic_auth_pass: T.nilable(String)).void } + def initialize(target_host, basic_auth_user, basic_auth_pass); end + + sig { returns(String) } + def target_host; end + + sig { params(_: String).void } + def target_host=(_); end + + sig { returns(T.nilable(String)) } + def basic_auth_user; end + + sig { params(_: T.nilable(String)).void } + def basic_auth_user=(_); end + + sig { returns(T.nilable(String)) } + def basic_auth_pass; end + + sig { params(_: T.nilable(String)).void } + def basic_auth_pass=(_); end +end + +class Temporalio::Internal::Bridge::Client::DnsLoadBalancingOptions < ::Struct + extend T::Sig + + sig { params(resolution_interval: T.any(Integer, Float)).void } + def initialize(resolution_interval); end + + sig { returns(T.any(Integer, Float)) } + def resolution_interval; end + + sig { params(_: T.any(Integer, Float)).void } + def resolution_interval=(_); end +end + +class Temporalio::Internal::Bridge::Client::RPCFailure < Temporalio::Error + extend T::Sig + + sig { returns(Integer) } + def code; end + + sig { returns(String) } + def message; end + + sig { returns(T.nilable(String)) } + def details; end +end + +class Temporalio::Internal::Bridge::Client::CancellationToken + extend T::Sig + + sig { returns(Temporalio::Internal::Bridge::Client::CancellationToken) } + def self.new; end + + sig { void } + def cancel; end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/runtime.rbi b/temporalio/rbi/temporalio/internal/bridge/runtime.rbi new file mode 100644 index 00000000..bc1d6a0d --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/runtime.rbi @@ -0,0 +1,231 @@ +# typed: true + +class Temporalio::Internal::Bridge::Runtime + extend T::Sig + + sig { params(options: Temporalio::Internal::Bridge::Runtime::Options).returns(Temporalio::Internal::Bridge::Runtime) } + def self.new(options); end + + sig { void } + def run_command_loop; end + + sig { params(durations_as_seconds: T::Boolean).returns(T::Array[Temporalio::Runtime::MetricBuffer::Update]) } + def retrieve_buffered_metrics(durations_as_seconds); end +end + +class Temporalio::Internal::Bridge::Runtime::Options < ::Struct + extend T::Sig + + sig do + params( + telemetry: Temporalio::Internal::Bridge::Runtime::TelemetryOptions, + worker_heartbeat_interval: T.nilable(T.any(Integer, Float)) + ).void + end + def initialize(telemetry, worker_heartbeat_interval); end + + sig { returns(Temporalio::Internal::Bridge::Runtime::TelemetryOptions) } + def telemetry; end + + sig { params(_: Temporalio::Internal::Bridge::Runtime::TelemetryOptions).void } + def telemetry=(_); end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def worker_heartbeat_interval; end + + sig { params(_: T.nilable(T.any(Integer, Float))).void } + def worker_heartbeat_interval=(_); end +end + +class Temporalio::Internal::Bridge::Runtime::TelemetryOptions < ::Struct + extend T::Sig + + sig do + params( + logging: T.nilable(Temporalio::Internal::Bridge::Runtime::LoggingOptions), + metrics: T.nilable(Temporalio::Internal::Bridge::Runtime::MetricsOptions) + ).void + end + def initialize(logging, metrics); end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Runtime::LoggingOptions)) } + def logging; end + + sig { params(_: T.nilable(Temporalio::Internal::Bridge::Runtime::LoggingOptions)).void } + def logging=(_); end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Runtime::MetricsOptions)) } + def metrics; end + + sig { params(_: T.nilable(Temporalio::Internal::Bridge::Runtime::MetricsOptions)).void } + def metrics=(_); end +end + +class Temporalio::Internal::Bridge::Runtime::LoggingOptions < ::Struct + extend T::Sig + + sig { params(log_filter: T.nilable(String)).void } + def initialize(log_filter); end + + sig { returns(T.nilable(String)) } + def log_filter; end + + sig { params(_: T.nilable(String)).void } + def log_filter=(_); end +end + +class Temporalio::Internal::Bridge::Runtime::MetricsOptions < ::Struct + extend T::Sig + + sig do + params( + opentelemetry: T.nilable(Temporalio::Internal::Bridge::Runtime::OpenTelemetryMetricsOptions), + prometheus: T.nilable(Temporalio::Internal::Bridge::Runtime::PrometheusMetricsOptions), + buffered_with_size: T.nilable(Integer), + attach_service_name: T::Boolean, + global_tags: T.nilable(T::Hash[String, String]), + metric_prefix: T.nilable(String) + ).void + end + def initialize(opentelemetry, prometheus, buffered_with_size, attach_service_name, global_tags, metric_prefix); end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Runtime::OpenTelemetryMetricsOptions)) } + def opentelemetry; end + + sig { params(_: T.nilable(Temporalio::Internal::Bridge::Runtime::OpenTelemetryMetricsOptions)).void } + def opentelemetry=(_); end + + sig { returns(T.nilable(Temporalio::Internal::Bridge::Runtime::PrometheusMetricsOptions)) } + def prometheus; end + + sig { params(_: T.nilable(Temporalio::Internal::Bridge::Runtime::PrometheusMetricsOptions)).void } + def prometheus=(_); end + + sig { returns(T.nilable(Integer)) } + def buffered_with_size; end + + sig { params(_: T.nilable(Integer)).void } + def buffered_with_size=(_); end + + sig { returns(T::Boolean) } + def attach_service_name; end + + sig { params(_: T::Boolean).void } + def attach_service_name=(_); end + + sig { returns(T.nilable(T::Hash[String, String])) } + def global_tags; end + + sig { params(_: T.nilable(T::Hash[String, String])).void } + def global_tags=(_); end + + sig { returns(T.nilable(String)) } + def metric_prefix; end + + sig { params(_: T.nilable(String)).void } + def metric_prefix=(_); end +end + +class Temporalio::Internal::Bridge::Runtime::OpenTelemetryMetricsOptions < ::Struct + extend T::Sig + + sig do + params( + url: String, + headers: T.nilable(T::Hash[String, String]), + metric_periodicity: T.nilable(T.any(Integer, Float)), + metric_temporality_delta: T::Boolean, + durations_as_seconds: T::Boolean, + http: T::Boolean, + histogram_bucket_overrides: T.nilable(T::Hash[String, T::Array[Numeric]]) + ).void + end + def initialize(url, headers, metric_periodicity, metric_temporality_delta, durations_as_seconds, http, histogram_bucket_overrides); end + + sig { returns(String) } + def url; end + + sig { params(_: String).void } + def url=(_); end + + sig { returns(T.nilable(T::Hash[String, String])) } + def headers; end + + sig { params(_: T.nilable(T::Hash[String, String])).void } + def headers=(_); end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def metric_periodicity; end + + sig { params(_: T.nilable(T.any(Integer, Float))).void } + def metric_periodicity=(_); end + + sig { returns(T::Boolean) } + def metric_temporality_delta; end + + sig { params(_: T::Boolean).void } + def metric_temporality_delta=(_); end + + sig { returns(T::Boolean) } + def durations_as_seconds; end + + sig { params(_: T::Boolean).void } + def durations_as_seconds=(_); end + + sig { returns(T::Boolean) } + def http; end + + sig { params(_: T::Boolean).void } + def http=(_); end + + sig { returns(T.nilable(T::Hash[String, T::Array[Numeric]])) } + def histogram_bucket_overrides; end + + sig { params(_: T.nilable(T::Hash[String, T::Array[Numeric]])).void } + def histogram_bucket_overrides=(_); end +end + +class Temporalio::Internal::Bridge::Runtime::PrometheusMetricsOptions < ::Struct + extend T::Sig + + sig do + params( + bind_address: String, + counters_total_suffix: T::Boolean, + unit_suffix: T::Boolean, + durations_as_seconds: T::Boolean, + histogram_bucket_overrides: T.nilable(T::Hash[String, T::Array[Numeric]]) + ).void + end + def initialize(bind_address, counters_total_suffix, unit_suffix, durations_as_seconds, histogram_bucket_overrides); end + + sig { returns(String) } + def bind_address; end + + sig { params(_: String).void } + def bind_address=(_); end + + sig { returns(T::Boolean) } + def counters_total_suffix; end + + sig { params(_: T::Boolean).void } + def counters_total_suffix=(_); end + + sig { returns(T::Boolean) } + def unit_suffix; end + + sig { params(_: T::Boolean).void } + def unit_suffix=(_); end + + sig { returns(T::Boolean) } + def durations_as_seconds; end + + sig { params(_: T::Boolean).void } + def durations_as_seconds=(_); end + + sig { returns(T.nilable(T::Hash[String, T::Array[Numeric]])) } + def histogram_bucket_overrides; end + + sig { params(_: T.nilable(T::Hash[String, T::Array[Numeric]])).void } + def histogram_bucket_overrides=(_); end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/testing.rbi b/temporalio/rbi/temporalio/internal/bridge/testing.rbi new file mode 100644 index 00000000..e7d4a7d1 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/testing.rbi @@ -0,0 +1,109 @@ +# typed: true + +module Temporalio::Internal::Bridge::Testing; end + +class Temporalio::Internal::Bridge::Testing::EphemeralServer + extend T::Sig + + sig do + params( + runtime: Temporalio::Internal::Bridge::Runtime, + options: Temporalio::Internal::Bridge::Testing::EphemeralServer::StartDevServerOptions + ).returns(Temporalio::Internal::Bridge::Testing::EphemeralServer) + end + def self.start_dev_server(runtime, options); end + + sig do + params( + runtime: Temporalio::Internal::Bridge::Runtime, + options: Temporalio::Internal::Bridge::Testing::EphemeralServer::StartTestServerOptions + ).returns(Temporalio::Internal::Bridge::Testing::EphemeralServer) + end + def self.start_test_server(runtime, options); end + + sig { void } + def shutdown; end + + sig do + params( + runtime: Temporalio::Internal::Bridge::Runtime, + options: Temporalio::Internal::Bridge::Testing::EphemeralServer::StartDevServerOptions, + queue: Queue + ).void + end + def self.async_start_dev_server(runtime, options, queue); end + + sig do + params( + runtime: Temporalio::Internal::Bridge::Runtime, + options: Temporalio::Internal::Bridge::Testing::EphemeralServer::StartTestServerOptions, + queue: Queue + ).void + end + def self.async_start_test_server(runtime, options, queue); end + + sig { returns(String) } + def target; end + + sig { params(queue: Queue).void } + def async_shutdown(queue); end +end + +class Temporalio::Internal::Bridge::Testing::EphemeralServer::StartDevServerOptions < ::Struct + extend T::Sig + + sig do + params( + existing_path: T.nilable(String), + sdk_name: String, + sdk_version: String, + download_version: String, + download_dest_dir: T.nilable(String), + namespace: String, + ip: String, + port: T.nilable(Integer), + database_filename: T.nilable(String), + ui: T::Boolean, + ui_port: T.nilable(Integer), + log_format: String, + log_level: String, + extra_args: T::Array[String], + download_ttl: T.nilable(T.any(Integer, Float)) + ).void + end + def initialize( + existing_path, + sdk_name, + sdk_version, + download_version, + download_dest_dir, + namespace, + ip, + port, + database_filename, + ui, + ui_port, + log_format, + log_level, + extra_args, + download_ttl + ); end +end + +class Temporalio::Internal::Bridge::Testing::EphemeralServer::StartTestServerOptions < ::Struct + extend T::Sig + + sig do + params( + existing_path: T.nilable(String), + sdk_name: String, + sdk_version: String, + download_version: String, + download_dest_dir: T.nilable(String), + port: T.nilable(Integer), + extra_args: T::Array[String], + download_ttl: T.nilable(T.any(Integer, Float)) + ).void + end + def initialize(existing_path, sdk_name, sdk_version, download_version, download_dest_dir, port, extra_args, download_ttl); end +end diff --git a/temporalio/rbi/temporalio/internal/bridge/worker.rbi b/temporalio/rbi/temporalio/internal/bridge/worker.rbi new file mode 100644 index 00000000..e2044341 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/bridge/worker.rbi @@ -0,0 +1,250 @@ +# typed: true + +class Temporalio::Internal::Bridge::Worker + extend T::Sig + + sig { params(workers: T::Array[Temporalio::Internal::Bridge::Worker]).void } + def self.finalize_shutdown_all(workers); end + + sig { void } + def validate; end + + sig { params(proto: Object).void } + def complete_activity_task(proto); end + + sig { params(proto: Object).void } + def complete_activity_task_in_background(proto); end + + sig do + params( + client: Temporalio::Internal::Bridge::Client, + options: Temporalio::Internal::Bridge::Worker::Options + ).returns(Temporalio::Internal::Bridge::Worker) + end + def self.new(client, options); end + + sig { params(workers: T::Array[Temporalio::Internal::Bridge::Worker], queue: Queue).void } + def self.async_poll_all(workers, queue); end + + sig { params(workers: T::Array[Temporalio::Internal::Bridge::Worker], queue: Queue).void } + def self.async_finalize_all(workers, queue); end + + sig { params(queue: Queue).void } + def async_validate(queue); end + + sig { params(proto: String, queue: Queue).void } + def async_complete_activity_task(proto, queue); end + + sig { params(run_id: String, proto: String, queue: Queue).void } + def async_complete_workflow_activation(run_id, proto, queue); end + + sig { params(proto: String).void } + def record_activity_heartbeat(proto); end + + sig { params(client: Temporalio::Internal::Bridge::Client).void } + def replace_client(client); end + + sig { void } + def initiate_shutdown; end +end + +class Temporalio::Internal::Bridge::Worker::Options < ::Struct + extend T::Sig + + sig do + params( + namespace: String, + task_queue: String, + tuner: Temporalio::Internal::Bridge::Worker::TunerOptions, + identity_override: T.nilable(String), + max_cached_workflows: Integer, + workflow_task_poller_behavior: T.any( + Temporalio::Internal::Bridge::Worker::PollerBehaviorSimpleMaximum, + Temporalio::Internal::Bridge::Worker::PollerBehaviorAutoscaling + ), + nonsticky_to_sticky_poll_ratio: T.any(Integer, Float), + activity_task_poller_behavior: T.any( + Temporalio::Internal::Bridge::Worker::PollerBehaviorSimpleMaximum, + Temporalio::Internal::Bridge::Worker::PollerBehaviorAutoscaling + ), + enable_workflows: T::Boolean, + enable_local_activities: T::Boolean, + enable_remote_activities: T::Boolean, + enable_nexus: T::Boolean, + sticky_queue_schedule_to_start_timeout: T.any(Integer, Float), + max_heartbeat_throttle_interval: T.any(Integer, Float), + default_heartbeat_throttle_interval: T.any(Integer, Float), + max_worker_activities_per_second: T.nilable(T.any(Integer, Float)), + max_task_queue_activities_per_second: T.nilable(T.any(Integer, Float)), + graceful_shutdown_period: T.any(Integer, Float), + nondeterminism_as_workflow_fail: T::Boolean, + nondeterminism_as_workflow_fail_for_types: T::Array[String], + deployment_options: T.nilable(Temporalio::Internal::Bridge::Worker::DeploymentOptions), + plugins: T::Array[String] + ).void + end + def initialize( + namespace, + task_queue, + tuner, + identity_override, + max_cached_workflows, + workflow_task_poller_behavior, + nonsticky_to_sticky_poll_ratio, + activity_task_poller_behavior, + enable_workflows, + enable_local_activities, + enable_remote_activities, + enable_nexus, + sticky_queue_schedule_to_start_timeout, + max_heartbeat_throttle_interval, + default_heartbeat_throttle_interval, + max_worker_activities_per_second, + max_task_queue_activities_per_second, + graceful_shutdown_period, + nondeterminism_as_workflow_fail, + nondeterminism_as_workflow_fail_for_types, + deployment_options, + plugins + ); end +end + +class Temporalio::Internal::Bridge::Worker::TunerOptions < ::Struct + extend T::Sig + + sig do + params( + workflow_slot_supplier: Temporalio::Internal::Bridge::Worker::TunerSlotSupplierOptions, + activity_slot_supplier: Temporalio::Internal::Bridge::Worker::TunerSlotSupplierOptions, + local_activity_slot_supplier: Temporalio::Internal::Bridge::Worker::TunerSlotSupplierOptions + ).void + end + def initialize(workflow_slot_supplier, activity_slot_supplier, local_activity_slot_supplier); end +end + +class Temporalio::Internal::Bridge::Worker::TunerSlotSupplierOptions < ::Struct + extend T::Sig + + sig do + params( + fixed_size: T.nilable(Integer), + resource_based: T.nilable(Temporalio::Internal::Bridge::Worker::TunerResourceBasedSlotSupplierOptions), + custom: T.nilable(Temporalio::Internal::Bridge::Worker::CustomSlotSupplier) + ).void + end + def initialize(fixed_size, resource_based, custom); end +end + +class Temporalio::Internal::Bridge::Worker::TunerResourceBasedSlotSupplierOptions < ::Struct + extend T::Sig + + sig do + params( + target_mem_usage: T.any(Integer, Float), + target_cpu_usage: T.any(Integer, Float), + min_slots: T.nilable(Integer), + max_slots: T.nilable(Integer), + ramp_throttle: T.nilable(T.any(Integer, Float)) + ).void + end + def initialize(target_mem_usage, target_cpu_usage, min_slots, max_slots, ramp_throttle); end +end + +class Temporalio::Internal::Bridge::Worker::CustomSlotSupplier + extend T::Sig + + sig do + params( + slot_supplier: Temporalio::Worker::Tuner::SlotSupplier::Custom, + thread_pool: T.nilable(Temporalio::Worker::ThreadPool) + ).void + end + def initialize(slot_supplier:, thread_pool:); end + + sig do + params( + context: Temporalio::Worker::Tuner::SlotSupplier::Custom::ReserveContext, + cancellation: Temporalio::Cancellation, + block: T.proc.params(arg0: Object).void + ).void + end + def reserve_slot(context, cancellation, &block); end + + sig do + params( + context: Temporalio::Worker::Tuner::SlotSupplier::Custom::ReserveContext, + block: T.proc.params(arg0: Object).void + ).void + end + def try_reserve_slot(context, &block); end + + sig do + params( + context: Temporalio::Worker::Tuner::SlotSupplier::Custom::MarkUsedContext, + block: T.proc.params(arg0: Object).void + ).void + end + def mark_slot_used(context, &block); end + + sig do + params( + context: Temporalio::Worker::Tuner::SlotSupplier::Custom::ReleaseContext, + block: T.proc.params(arg0: Object).void + ).void + end + def release_slot(context, &block); end + + private + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def run_user_code(&block); end +end + +class Temporalio::Internal::Bridge::Worker::WorkerDeploymentVersion < ::Struct + extend T::Sig + + sig { params(deployment_name: String, build_id: String).void } + def initialize(deployment_name, build_id); end +end + +class Temporalio::Internal::Bridge::Worker::DeploymentOptions < ::Struct + extend T::Sig + + sig do + params( + version: Temporalio::Internal::Bridge::Worker::WorkerDeploymentVersion, + use_worker_versioning: T::Boolean, + default_versioning_behavior: Integer + ).void + end + def initialize(version, use_worker_versioning, default_versioning_behavior); end +end + +class Temporalio::Internal::Bridge::Worker::PollerBehaviorSimpleMaximum < ::Struct + extend T::Sig + + sig { params(simple_maximum: Integer).void } + def initialize(simple_maximum); end +end + +class Temporalio::Internal::Bridge::Worker::PollerBehaviorAutoscaling < ::Struct + extend T::Sig + + sig { params(minimum: Integer, maximum: Integer, initial: Integer).void } + def initialize(minimum, maximum, initial); end +end + +class Temporalio::Internal::Bridge::Worker::WorkflowReplayer + extend T::Sig + + sig do + params( + runtime: Temporalio::Internal::Bridge::Runtime, + options: Temporalio::Internal::Bridge::Worker::Options + ).returns([Temporalio::Internal::Bridge::Worker::WorkflowReplayer, Temporalio::Internal::Bridge::Worker]) + end + def self.new(runtime, options); end + + sig { params(workflow_id: String, proto: String).void } + def push_history(workflow_id, proto); end +end diff --git a/temporalio/rbi/temporalio/internal/client/implementation.rbi b/temporalio/rbi/temporalio/internal/client/implementation.rbi new file mode 100644 index 00000000..f65ad47a --- /dev/null +++ b/temporalio/rbi/temporalio/internal/client/implementation.rbi @@ -0,0 +1,23 @@ +# typed: true + +class Temporalio::Internal::Client::Implementation < Temporalio::Client::Interceptor::Outbound + extend T::Sig + + sig do + params( + user_rpc_options: T.nilable(Temporalio::Client::RPCOptions) + ).returns(Temporalio::Client::RPCOptions) + end + def self.with_default_rpc_options(user_rpc_options); end + + sig { params(client: Temporalio::Client).void } + def initialize(client); end + + sig do + params( + klass: Class, + start_options: Temporalio::Client::WithStartWorkflowOperation::Options + ).returns(Object) + end + def _start_workflow_request_from_with_start_options(klass, start_options); end +end diff --git a/temporalio/rbi/temporalio/internal/metric.rbi b/temporalio/rbi/temporalio/internal/metric.rbi new file mode 100644 index 00000000..6d47c858 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/metric.rbi @@ -0,0 +1,55 @@ +# typed: true + +class Temporalio::Internal::Metric < Temporalio::Metric + extend T::Sig + + sig do + params( + metric_type: Symbol, + name: String, + description: T.nilable(String), + unit: T.nilable(String), + value_type: Symbol, + bridge: Temporalio::Internal::Bridge::Metric, + bridge_attrs: Temporalio::Internal::Bridge::Metric::Attributes + ).void + end + def initialize(metric_type:, name:, description:, unit:, value_type:, bridge:, bridge_attrs:); end +end + +class Temporalio::Internal::Metric::Meter < Temporalio::Metric::Meter + extend T::Sig + + sig { params(runtime: Temporalio::Runtime).returns(T.nilable(Temporalio::Internal::Metric::Meter)) } + def self.create_from_runtime(runtime); end + + sig do + params( + bridge: Temporalio::Internal::Bridge::Metric::Meter, + bridge_attrs: Temporalio::Internal::Bridge::Metric::Attributes + ).void + end + def initialize(bridge, bridge_attrs); end +end + +class Temporalio::Internal::Metric::NullMeter < Temporalio::Metric::Meter + extend T::Sig + + sig { returns(Temporalio::Internal::Metric::NullMeter) } + def self.instance; end +end + +class Temporalio::Internal::Metric::NullMetric < Temporalio::Metric + extend T::Sig + + sig do + params( + metric_type: Symbol, + name: String, + description: T.nilable(String), + unit: T.nilable(String), + value_type: Symbol + ).void + end + def initialize(metric_type:, name:, description:, unit:, value_type:); end +end diff --git a/temporalio/rbi/temporalio/internal/proto_utils.rbi b/temporalio/rbi/temporalio/internal/proto_utils.rbi new file mode 100644 index 00000000..bf83cafc --- /dev/null +++ b/temporalio/rbi/temporalio/internal/proto_utils.rbi @@ -0,0 +1,148 @@ +# typed: true + +module Temporalio::Internal::ProtoUtils + extend T::Sig + + sig { params(seconds_numeric: T.nilable(T.any(Integer, Float))).returns(T.nilable(Google::Protobuf::Duration)) } + def self.seconds_to_duration(seconds_numeric); end + + sig { params(duration: T.nilable(Google::Protobuf::Duration)).returns(T.nilable(Float)) } + def self.duration_to_seconds(duration); end + + sig { params(time: T.nilable(Time)).returns(T.nilable(Google::Protobuf::Timestamp)) } + def self.time_to_timestamp(time); end + + sig { params(timestamp: T.nilable(Google::Protobuf::Timestamp)).returns(T.nilable(Time)) } + def self.timestamp_to_time(timestamp); end + + sig do + params( + hash: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T.nilable(Temporalio::Api::Common::V1::Memo)) + end + def self.memo_to_proto(hash, converter); end + + sig do + params( + hash: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T.nilable(T::Hash[String, Temporalio::Api::Common::V1::Payload])) + end + def self.memo_to_proto_hash(hash, converter); end + + sig do + params( + memo: T.nilable(Temporalio::Api::Common::V1::Memo), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T.nilable(T::Hash[String, T.nilable(Object)])) + end + def self.memo_from_proto(memo, converter); end + + sig do + params( + headers: T.nilable(T::Hash[String, T.nilable(Object)]), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T.nilable(Temporalio::Api::Common::V1::Header)) + end + def self.headers_to_proto(headers, converter); end + + sig do + params( + headers: T.nilable(T::Hash[String, T.nilable(Object)]), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T.nilable(T::Hash[String, Temporalio::Api::Common::V1::Payload])) + end + def self.headers_to_proto_hash(headers, converter); end + + sig do + params( + headers: T.nilable(Temporalio::Api::Common::V1::Header), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T.nilable(T::Hash[String, T.nilable(Object)])) + end + def self.headers_from_proto(headers, converter); end + + sig do + params( + headers: T.nilable(Google::Protobuf::Map), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T.nilable(T::Hash[String, Temporalio::Api::Common::V1::Payload])) + end + def self.headers_from_proto_map(headers, converter); end + + sig { params(str: T.nilable(String), default: T.nilable(String)).returns(T.nilable(String)) } + def self.string_or(str, default = nil); end + + sig do + params(enum_mod: Module, enum_val: T.any(Symbol, Integer, Float), zero_means_nil: T::Boolean) + .returns(T.nilable(Integer)) + end + def self.enum_to_int(enum_mod, enum_val, zero_means_nil: false); end + + sig do + params( + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter), + payloads: T::Array[Temporalio::Api::Common::V1::Payload], + hints: T.nilable(T::Array[Object]) + ).returns(T::Array[T.nilable(Object)]) + end + def self.convert_from_payload_array(converter, payloads, hints:); end + + sig do + params( + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter), + values: T::Array[T.nilable(Object)], + hints: T.nilable(T::Array[Object]) + ).returns(T::Array[Temporalio::Api::Common::V1::Payload]) + end + def self.convert_to_payload_array(converter, values, hints:); end + + sig { params(name: T.nilable(T.any(String, Symbol))).void } + def self.assert_non_reserved_name(name); end + + sig { params(name: T.nilable(T.any(String, Symbol))).returns(T::Boolean) } + def self.reserved_name?(name); end + + sig do + params( + summary: T.nilable(String), + details: T.nilable(String), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T.nilable(Temporalio::Api::Sdk::V1::UserMetadata)) + end + def self.to_user_metadata(summary, details, converter); end + + sig do + params( + metadata: T.nilable(Temporalio::Api::Sdk::V1::UserMetadata), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).returns(T::Array[T.nilable(String)]) + end + def self.from_user_metadata(metadata, converter); end +end + +class Temporalio::Internal::ProtoUtils::LazyMemo + extend T::Sig + + sig do + params( + raw_memo: T.nilable(Temporalio::Api::Common::V1::Memo), + converter: T.any(Temporalio::Converters::DataConverter, Temporalio::Converters::PayloadConverter) + ).void + end + def initialize(raw_memo, converter); end + + sig { returns(T.nilable(T::Hash[String, T.nilable(Object)])) } + def get; end +end + +class Temporalio::Internal::ProtoUtils::LazySearchAttributes + extend T::Sig + + sig { params(raw_search_attributes: T.nilable(Temporalio::Api::Common::V1::SearchAttributes)).void } + def initialize(raw_search_attributes); end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def get; end +end diff --git a/temporalio/rbi/temporalio/internal/worker/activity_worker.rbi b/temporalio/rbi/temporalio/internal/worker/activity_worker.rbi new file mode 100644 index 00000000..48a46672 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/activity_worker.rbi @@ -0,0 +1,108 @@ +# typed: true + +class Temporalio::Internal::Worker::ActivityWorker + extend T::Sig + + LOG_TASKS = T.let(T.unsafe(nil), T::Boolean) + + sig { returns(Temporalio::Worker) } + attr_reader :worker + + sig { returns(Temporalio::Internal::Bridge::Worker) } + attr_reader :bridge_worker + + sig { params(worker: Temporalio::Worker, bridge_worker: Temporalio::Internal::Bridge::Worker).void } + def initialize(worker:, bridge_worker:); end + + sig do + params( + task_token: String, + activity: T.nilable(Temporalio::Internal::Worker::ActivityWorker::RunningActivity) + ).void + end + def set_running_activity(task_token, activity); end + + sig { params(task_token: String).returns(T.nilable(Temporalio::Internal::Worker::ActivityWorker::RunningActivity)) } + def get_running_activity(task_token); end + + sig { params(task_token: String).void } + def remove_running_activity(task_token); end + + sig { void } + def wait_all_complete; end + + sig { params(task: Object).void } + def handle_task(task); end + + sig { params(task_token: String, start: Object).void } + def handle_start_task(task_token, start); end + + sig { params(task_token: String, cancel: Object).void } + def handle_cancel_task(task_token, cancel); end + + sig { params(task_token: String, defn: Temporalio::Activity::Definition::Info, start: Object).void } + def execute_activity(task_token, defn, start); end + + sig do + params( + defn: Temporalio::Activity::Definition::Info, + activity: Temporalio::Internal::Worker::ActivityWorker::RunningActivity, + input: Temporalio::Worker::Interceptor::Activity::ExecuteInput + ).void + end + def run_activity(defn, activity, input); end + + sig { params(activity: String).void } + def assert_valid_activity(activity); end +end + +class Temporalio::Internal::Worker::ActivityWorker::RunningActivity < Temporalio::Activity::Context + extend T::Sig + + sig { returns(T::Boolean) } + attr_reader :_server_requested_cancel + + sig { returns(T.nilable(Temporalio::Activity::Definition)) } + attr_accessor :instance + + sig { returns(T.nilable(Temporalio::Worker::Interceptor::Activity::Outbound)) } + attr_accessor :_outbound_impl + + sig do + params( + worker: Temporalio::Worker, + info: Temporalio::Activity::Info, + cancellation: Temporalio::Cancellation, + worker_shutdown_cancellation: Temporalio::Cancellation, + payload_converter: Temporalio::Converters::PayloadConverter, + logger: Temporalio::ScopedLogger, + runtime_metric_meter: Temporalio::Metric::Meter + ).void + end + def initialize( + worker:, + info:, + cancellation:, + worker_shutdown_cancellation:, + payload_converter:, + logger:, + runtime_metric_meter: + ); end + + sig { params(reason: String, details: Temporalio::Activity::CancellationDetails).void } + def _cancel(reason:, details:); end +end + +class Temporalio::Internal::Worker::ActivityWorker::InboundImplementation < Temporalio::Worker::Interceptor::Activity::Inbound + extend T::Sig + + sig { params(worker: Temporalio::Internal::Worker::ActivityWorker).void } + def initialize(worker); end +end + +class Temporalio::Internal::Worker::ActivityWorker::OutboundImplementation < Temporalio::Worker::Interceptor::Activity::Outbound + extend T::Sig + + sig { params(worker: Temporalio::Internal::Worker::ActivityWorker, task_token: String).void } + def initialize(worker, task_token); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/multi_runner.rbi b/temporalio/rbi/temporalio/internal/worker/multi_runner.rbi new file mode 100644 index 00000000..5bbbd8b4 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/multi_runner.rbi @@ -0,0 +1,175 @@ +# typed: true + +class Temporalio::Internal::Worker::MultiRunner + extend T::Sig + + sig { params(workers: T::Array[Object], shutdown_signals: T::Array[T.any(String, Integer)]).void } + def initialize(workers:, shutdown_signals:); end + + sig { params(block: T.nilable(T.proc.returns(Object))).void } + def apply_thread_or_fiber_block(&block); end + + sig { params(workflow_worker: Temporalio::Internal::Worker::WorkflowWorker, activation: Object).void } + def apply_workflow_activation_decoded(workflow_worker:, activation:); end + + sig do + params( + workflow_worker: Temporalio::Internal::Worker::WorkflowWorker, + activation_completion: Object, + encoded: T::Boolean + ).void + end + def apply_workflow_activation_complete(workflow_worker:, activation_completion:, encoded:); end + + sig { params(error: Exception).void } + def raise_in_thread_or_fiber_block(error); end + + sig { void } + def initiate_shutdown; end + + sig { void } + def wait_complete_and_finalize_shutdown; end + + sig { returns(Temporalio::Internal::Worker::MultiRunner::Event) } + def next_event; end +end + +class Temporalio::Internal::Worker::MultiRunner::Event +end + +class Temporalio::Internal::Worker::MultiRunner::Event::PollSuccess < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(Object) } + attr_reader :worker + + sig { returns(Symbol) } + attr_reader :worker_type + + sig { returns(String) } + attr_reader :bytes + + sig { params(worker: Object, worker_type: Symbol, bytes: String).void } + def initialize(worker:, worker_type:, bytes:); end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::PollFailure < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(Object) } + attr_reader :worker + + sig { returns(Symbol) } + attr_reader :worker_type + + sig { returns(Exception) } + attr_reader :error + + sig { params(worker: Object, worker_type: Symbol, error: Exception).void } + def initialize(worker:, worker_type:, error:); end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::WorkflowActivationDecoded < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(Temporalio::Internal::Worker::WorkflowWorker) } + attr_reader :workflow_worker + + sig { returns(Object) } + attr_reader :activation + + sig { params(workflow_worker: Temporalio::Internal::Worker::WorkflowWorker, activation: Object).void } + def initialize(workflow_worker:, activation:); end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::WorkflowActivationComplete < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(Temporalio::Internal::Worker::WorkflowWorker) } + attr_reader :workflow_worker + + sig { returns(Object) } + attr_reader :activation_completion + + sig { returns(T::Boolean) } + attr_reader :encoded + + sig { returns(Queue) } + attr_reader :completion_complete_queue + + sig do + params( + workflow_worker: Temporalio::Internal::Worker::WorkflowWorker, + activation_completion: Object, + encoded: T::Boolean, + completion_complete_queue: Queue + ).void + end + def initialize(workflow_worker:, activation_completion:, encoded:, completion_complete_queue:); end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::WorkflowActivationCompletionComplete < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(String) } + attr_reader :run_id + + sig { returns(T.nilable(Exception)) } + attr_reader :error + + sig { params(run_id: String, error: T.nilable(Exception)).void } + def initialize(run_id:, error:); end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::PollerShutDown < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(Object) } + attr_reader :worker + + sig { returns(Symbol) } + attr_reader :worker_type + + sig { params(worker: Object, worker_type: Symbol).void } + def initialize(worker:, worker_type:); end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::AllPollersShutDown < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(Temporalio::Internal::Worker::MultiRunner::Event::AllPollersShutDown) } + def self.instance; end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::BlockSuccess < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(T.nilable(Object)) } + attr_reader :result + + sig { params(result: T.nilable(Object)).void } + def initialize(result:); end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::BlockFailure < Temporalio::Internal::Worker::MultiRunner::Event + extend T::Sig + + sig { returns(Exception) } + attr_reader :error + + sig { params(error: Exception).void } + def initialize(error:); end +end + +class Temporalio::Internal::Worker::MultiRunner::Event::ShutdownSignalReceived < Temporalio::Internal::Worker::MultiRunner::Event +end + +class Temporalio::Internal::Worker::MultiRunner::InjectEventForTesting < Temporalio::Error + extend T::Sig + + sig { returns(Temporalio::Internal::Worker::MultiRunner::Event) } + attr_reader :event + + sig { params(event: Temporalio::Internal::Worker::MultiRunner::Event).void } + def initialize(event); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance.rbi new file mode 100644 index 00000000..d2f7a719 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance.rbi @@ -0,0 +1,218 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance + extend T::Sig + + sig do + params( + run_id: String, + error: Exception, + failure_converter: Temporalio::Converters::FailureConverter, + payload_converter: Temporalio::Converters::PayloadConverter + ).returns(Object) + end + def self.new_completion_with_failure(run_id:, error:, failure_converter:, payload_converter:); end + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::Context) } + attr_reader :context + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeLogger) } + attr_reader :logger + + sig { returns(Temporalio::Workflow::Info) } + attr_reader :info + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::Scheduler) } + attr_reader :scheduler + + sig { returns(T::Boolean) } + attr_reader :disable_eager_activity_execution + + sig { returns(T::Hash[Integer, Fiber]) } + attr_reader :pending_activities + + sig { returns(T::Hash[Integer, Fiber]) } + attr_reader :pending_timers + + sig { returns(T::Hash[Integer, Fiber]) } + attr_reader :pending_child_workflow_starts + + sig { returns(T::Hash[Integer, Temporalio::Internal::Worker::WorkflowInstance::ChildWorkflowHandle]) } + attr_reader :pending_child_workflows + + sig { returns(T::Hash[Integer, Fiber]) } + attr_reader :pending_nexus_operation_starts + + sig { returns(T::Hash[Integer, Temporalio::Internal::Worker::WorkflowInstance::NexusOperationHandle]) } + attr_reader :pending_nexus_operations + + sig { returns(T::Hash[Integer, Fiber]) } + attr_reader :pending_external_signals + + sig { returns(T::Hash[Integer, Fiber]) } + attr_reader :pending_external_cancels + + sig { returns(T::Array[Temporalio::Internal::Worker::WorkflowInstance::HandlerExecution]) } + attr_reader :in_progress_handlers + + sig { returns(Temporalio::Converters::PayloadConverter) } + attr_reader :payload_converter + + sig { returns(Temporalio::Converters::FailureConverter) } + attr_reader :failure_converter + + sig { returns(Temporalio::Cancellation) } + attr_reader :cancellation + + sig { returns(T::Boolean) } + attr_reader :continue_as_new_suggested + + sig { returns(T::Array[Integer]) } + attr_reader :suggest_continue_as_new_reasons + + sig { returns(T::Boolean) } + attr_reader :target_worker_deployment_version_changed + + sig { returns(T.nilable(Temporalio::WorkerDeploymentVersion)) } + attr_reader :current_deployment_version + + sig { returns(Integer) } + attr_reader :current_history_length + + sig { returns(Integer) } + attr_reader :current_history_size + + sig { returns(T::Boolean) } + attr_reader :replaying + + sig { returns(Random) } + attr_reader :random + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Signal]) } + attr_reader :signal_handlers + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Query]) } + attr_reader :query_handlers + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Update]) } + attr_reader :update_handlers + + sig { returns(T::Boolean) } + attr_reader :context_frozen + + sig { returns(T.proc.params(arg0: String).void) } + attr_reader :assert_valid_local_activity + + sig { returns(T::Boolean) } + attr_reader :in_query_or_validator + + sig { returns(T::Boolean) } + attr_accessor :io_enabled + + sig { returns(T.nilable(String)) } + attr_accessor :current_details + + sig { params(details: Temporalio::Internal::Worker::WorkflowInstance::Details).void } + def initialize(details); end + + sig { params(activation: Object).returns(Object) } + def activate(activation); end + + sig { params(command: Object).void } + def add_command(command); end + + sig { returns(Temporalio::Workflow::Definition) } + def instance; end + + sig { returns(Temporalio::SearchAttributes) } + def search_attributes; end + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::ExternallyImmutableHash) } + def memo; end + + sig { returns(Time) } + def now; end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def illegal_call_tracing_disabled(&block); end + + sig { params(patch_id: T.any(Symbol, String), deprecated: T::Boolean).returns(T::Boolean) } + def patch(patch_id:, deprecated:); end + + sig { returns(Temporalio::Metric::Meter) } + def metric_meter; end + + private + + sig { returns(Temporalio::Workflow::Definition) } + def create_instance; end + + sig { params(job: Object).void } + def apply(job); end + + sig { params(job: Object).void } + def apply_signal(job); end + + sig { params(job: Object).void } + def apply_query(job); end + + sig { params(job: Object).void } + def apply_update(job); end + + sig { void } + def run_workflow; end + + sig do + params( + top_level: T::Boolean, + handler_exec: T.nilable(Temporalio::Internal::Worker::WorkflowInstance::HandlerExecution), + block: T.proc.returns(Object) + ).returns(Fiber) + end + def schedule(top_level: T.unsafe(nil), handler_exec: T.unsafe(nil), &block); end + + sig { params(err: Exception).void } + def on_top_level_exception(err); end + + sig { params(err: Exception).returns(T::Boolean) } + def failure_exception?(err); end + + sig do + type_parameters(:T) + .params(in_query_or_validator: T::Boolean, block: T.proc.returns(T.type_parameter(:T))) + .returns(T.type_parameter(:T)) + end + def with_context_frozen(in_query_or_validator:, &block); end + + sig do + params( + payload_array: Object, + defn: T.any( + Temporalio::Workflow::Definition::Signal, + Temporalio::Workflow::Definition::Query, + Temporalio::Workflow::Definition::Update + ) + ).returns(T::Array[T.nilable(Object)]) + end + def convert_handler_args(payload_array:, defn:); end + + sig do + params( + payload_array: Object, + method_name: T.nilable(Symbol), + raw_args: T::Boolean, + arg_hints: T.nilable(T::Array[Object]), + ignore_first_param: T::Boolean + ).returns(T::Array[T.nilable(Object)]) + end + def convert_args(payload_array:, method_name:, raw_args:, arg_hints:, ignore_first_param: T.unsafe(nil)); end + + sig { returns(Object) } + def workflow_metadata; end + + sig { returns(T::Hash[Symbol, T.nilable(Object)]) } + def scoped_logger_info; end + + sig { void } + def warn_on_any_unfinished_handlers; end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/child_workflow_handle.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/child_workflow_handle.rbi new file mode 100644 index 00000000..1d5814b0 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/child_workflow_handle.rbi @@ -0,0 +1,20 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::ChildWorkflowHandle < Temporalio::Workflow::ChildWorkflowHandle + extend T::Sig + + sig do + params( + id: String, + first_execution_run_id: String, + instance: Temporalio::Internal::Worker::WorkflowInstance, + cancellation: Temporalio::Cancellation, + cancel_callback_key: Object, + result_hint: T.nilable(Object) + ).void + end + def initialize(id:, first_execution_run_id:, instance:, cancellation:, cancel_callback_key:, result_hint:); end + + sig { params(resolution: Temporalio::Internal::Bridge::Api::ChildWorkflow::ChildWorkflowResult).void } + def _resolve(resolution); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/context.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/context.rbi new file mode 100644 index 00000000..acf0f559 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/context.rbi @@ -0,0 +1,290 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::Context + extend T::Sig + + sig { params(instance: Temporalio::Internal::Worker::WorkflowInstance).void } + def initialize(instance); end + + sig { returns(T::Boolean) } + def all_handlers_finished?; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T::Boolean) } + def continue_as_new_suggested; end + + sig { params(endpoint: T.any(Symbol, String), service: T.any(Symbol, String)).returns(Temporalio::Workflow::NexusClient) } + def create_nexus_client(endpoint:, service:); end + + sig { returns(T::Array[Integer]) } + def suggest_continue_as_new_reasons; end + + sig { returns(T::Boolean) } + def target_worker_deployment_version_changed?; end + + sig { returns(String) } + def current_details; end + + sig { params(details: T.nilable(String)).void } + def current_details=(details); end + + sig { returns(Integer) } + def current_history_length; end + + sig { returns(Integer) } + def current_history_size; end + + sig { returns(T.nilable(Temporalio::WorkerDeploymentVersion)) } + def current_deployment_version; end + + sig { returns(T.nilable(Temporalio::Workflow::UpdateInfo)) } + def current_update_info; end + + sig { params(patch_id: T.any(Symbol, String)).void } + def deprecate_patch(patch_id); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def durable_scheduler_disabled(&block); end + + sig do + params( + activity: T.any(T.class_of(Temporalio::Activity::Definition), Symbol, String), + args: T.nilable(Object), + task_queue: String, + summary: T.nilable(String), + schedule_to_close_timeout: T.nilable(T.any(Integer, Float)), + schedule_to_start_timeout: T.nilable(T.any(Integer, Float)), + start_to_close_timeout: T.nilable(T.any(Integer, Float)), + heartbeat_timeout: T.nilable(T.any(Integer, Float)), + retry_policy: T.nilable(Temporalio::RetryPolicy), + cancellation: Temporalio::Cancellation, + cancellation_type: Integer, + activity_id: T.nilable(String), + disable_eager_execution: T::Boolean, + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).returns(T.nilable(Object)) + end + def 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: + ); end + + sig do + params( + activity: T.any(T.class_of(Temporalio::Activity::Definition), Symbol, String), + args: T.nilable(Object), + summary: T.nilable(String), + schedule_to_close_timeout: T.nilable(T.any(Integer, Float)), + schedule_to_start_timeout: T.nilable(T.any(Integer, Float)), + start_to_close_timeout: T.nilable(T.any(Integer, Float)), + retry_policy: T.nilable(Temporalio::RetryPolicy), + local_retry_threshold: T.nilable(T.any(Integer, Float)), + cancellation: Temporalio::Cancellation, + cancellation_type: Integer, + activity_id: T.nilable(String), + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).returns(T.nilable(Object)) + end + def 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: + ); end + + sig do + params(workflow_id: String, run_id: T.nilable(String)) + .returns(Temporalio::Internal::Worker::WorkflowInstance::ExternalWorkflowHandle) + end + def external_workflow_handle(workflow_id, run_id: T.unsafe(nil)); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def illegal_call_tracing_disabled(&block); end + + sig { returns(Temporalio::Workflow::Info) } + def info; end + + sig { returns(Temporalio::Workflow::Definition) } + def instance; end + + sig { params(error: Temporalio::Workflow::ContinueAsNewError).void } + def initialize_continue_as_new_error(error); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def io_enabled(&block); end + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeLogger) } + def logger; end + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::ExternallyImmutableHash) } + def memo; end + + sig { returns(Temporalio::Metric::Meter) } + def metric_meter; end + + sig { returns(Time) } + def now; end + + sig { params(patch_id: T.any(Symbol, String)).returns(T::Boolean) } + def patched(patch_id); end + + sig { returns(Temporalio::Converters::PayloadConverter) } + def payload_converter; end + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::HandlerHash) } + def query_handlers; end + + sig { returns(Random) } + def random; end + + sig { returns(T::Boolean) } + def replaying?; end + + sig { returns(T::Boolean) } + def replaying_history_events?; end + + sig { returns(Temporalio::SearchAttributes) } + def search_attributes; end + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::HandlerHash) } + def signal_handlers; end + + sig { params(duration: T.nilable(T.any(Integer, Float)), summary: T.nilable(String), cancellation: Temporalio::Cancellation).void } + def sleep(duration, summary:, cancellation:); end + + sig do + params( + workflow: T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, String), + args: T.nilable(Object), + id: String, + task_queue: String, + static_summary: T.nilable(String), + static_details: T.nilable(String), + cancellation: Temporalio::Cancellation, + cancellation_type: Integer, + parent_close_policy: Integer, + execution_timeout: T.nilable(T.any(Integer, Float)), + run_timeout: T.nilable(T.any(Integer, Float)), + task_timeout: T.nilable(T.any(Integer, Float)), + id_reuse_policy: Integer, + retry_policy: T.nilable(Temporalio::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).returns(Temporalio::Internal::Worker::WorkflowInstance::ChildWorkflowHandle) + end + def 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:, + arg_hints:, + result_hint: + ); end + + sig { returns(T::Hash[Object, Object]) } + def storage; end + + sig do + type_parameters(:T) + .params( + duration: T.nilable(T.any(Integer, Float)), + exception_class: T.class_of(Exception), + exception_args: T.nilable(Object), + summary: T.nilable(String), + block: T.proc.returns(T.type_parameter(:T)) + ) + .returns(T.type_parameter(:T)) + end + def timeout(duration, exception_class, *exception_args, summary:, &block); end + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::HandlerHash) } + def update_handlers; end + + sig { params(hash: T::Hash[T.any(Symbol, String), T.nilable(Object)]).void } + def upsert_memo(hash); end + + sig { params(updates: Temporalio::SearchAttributes::Update).void } + def upsert_search_attributes(*updates); end + + sig do + type_parameters(:T) + .params(cancellation: T.nilable(Temporalio::Cancellation), block: T.proc.returns(T.type_parameter(:T))) + .returns(T.type_parameter(:T)) + end + def wait_condition(cancellation:, &block); end + + sig { params(id: String, run_id: T.nilable(String)).void } + def _cancel_external_workflow(id:, run_id:); end + + sig { params(outbound: Temporalio::Worker::Interceptor::Workflow::Outbound).void } + def _outbound=(outbound); end + + sig do + params( + id: String, + signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String), + args: T::Array[T.nilable(Object)], + cancellation: Temporalio::Cancellation, + arg_hints: T.nilable(T::Array[Object]) + ).void + end + def _signal_child_workflow(id:, signal:, args:, cancellation:, arg_hints:); end + + sig do + params( + id: String, + run_id: T.nilable(String), + signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String), + args: T::Array[T.nilable(Object)], + cancellation: Temporalio::Cancellation, + arg_hints: T.nilable(T::Array[Object]) + ).void + end + def _signal_external_workflow(id:, run_id:, signal:, args:, cancellation:, arg_hints:); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/details.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/details.rbi new file mode 100644 index 00000000..3f2f574b --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/details.rbi @@ -0,0 +1,82 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::Details + extend T::Sig + + sig { returns(String) } + attr_reader :namespace + + sig { returns(String) } + attr_reader :task_queue + + sig { returns(Temporalio::Workflow::Definition::Info) } + attr_reader :definition + + sig { returns(Object) } + attr_reader :initial_activation + + sig { returns(Logger) } + attr_reader :logger + + sig { returns(Temporalio::Metric::Meter) } + attr_reader :metric_meter + + sig { returns(Temporalio::Converters::PayloadConverter) } + attr_reader :payload_converter + + sig { returns(Temporalio::Converters::FailureConverter) } + attr_reader :failure_converter + + sig { returns(T::Array[Temporalio::Worker::Interceptor::Workflow]) } + attr_reader :interceptors + + sig { returns(T::Boolean) } + attr_reader :disable_eager_activity_execution + + sig { returns(T::Hash[String, Object]) } + attr_reader :illegal_calls + + sig { returns(T::Array[T.class_of(Exception)]) } + attr_reader :workflow_failure_exception_types + + sig { returns(T::Boolean) } + attr_reader :unsafe_workflow_io_enabled + + sig { returns(T.proc.params(arg0: String).void) } + attr_reader :assert_valid_local_activity + + sig do + params( + namespace: String, + task_queue: String, + definition: Temporalio::Workflow::Definition::Info, + initial_activation: Object, + logger: Logger, + metric_meter: Temporalio::Metric::Meter, + payload_converter: Temporalio::Converters::PayloadConverter, + failure_converter: Temporalio::Converters::FailureConverter, + interceptors: T::Array[Temporalio::Worker::Interceptor::Workflow], + disable_eager_activity_execution: T::Boolean, + illegal_calls: T::Hash[String, Object], + workflow_failure_exception_types: T::Array[T.class_of(Exception)], + unsafe_workflow_io_enabled: T::Boolean, + assert_valid_local_activity: T.proc.params(arg0: String).void + ).void + end + def initialize( + namespace:, + task_queue:, + definition:, + initial_activation:, + logger:, + metric_meter:, + payload_converter:, + failure_converter:, + interceptors:, + disable_eager_activity_execution:, + illegal_calls:, + workflow_failure_exception_types:, + unsafe_workflow_io_enabled:, + assert_valid_local_activity: + ); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/external_workflow_handle.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/external_workflow_handle.rbi new file mode 100644 index 00000000..afa37a29 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/external_workflow_handle.rbi @@ -0,0 +1,14 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::ExternalWorkflowHandle < Temporalio::Workflow::ExternalWorkflowHandle + extend T::Sig + + sig do + params( + id: String, + run_id: T.nilable(String), + instance: Object + ).void + end + def initialize(id:, run_id:, instance:); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/externally_immutable_hash.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/externally_immutable_hash.rbi new file mode 100644 index 00000000..c2739f62 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/externally_immutable_hash.rbi @@ -0,0 +1,17 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::ExternallyImmutableHash < Hash + extend T::Sig + + sig { params(initial_hash: T::Hash[Object, Object]).void } + def initialize(initial_hash); end + + sig { params(block: T.proc.params(arg0: T::Hash[Object, Object]).void).void } + def _update(&block); end + + sig { returns(T::Hash[Object, Object]) } + def __getobj__; end + + sig { params(obj: T::Hash[Object, Object]).void } + def __setobj__(obj); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/handler_execution.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/handler_execution.rbi new file mode 100644 index 00000000..bb71303b --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/handler_execution.rbi @@ -0,0 +1,17 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::HandlerExecution + extend T::Sig + + sig { returns(String) } + attr_reader :name + + sig { returns(T.nilable(String)) } + attr_reader :update_id + + sig { returns(Integer) } + attr_reader :unfinished_policy + + sig { params(name: String, update_id: T.nilable(String), unfinished_policy: Integer).void } + def initialize(name:, update_id:, unfinished_policy:); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/handler_hash.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/handler_hash.rbi new file mode 100644 index 00000000..84bdbc82 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/handler_hash.rbi @@ -0,0 +1,24 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::HandlerHash < Hash + extend T::Sig + + sig do + params( + initial_frozen_hash: T::Hash[T.nilable(String), Object], + definition_class: T.any( + T.class_of(Temporalio::Workflow::Definition::Signal), + T.class_of(Temporalio::Workflow::Definition::Query), + T.class_of(Temporalio::Workflow::Definition::Update) + ), + on_new_definition: T.nilable(T.proc.params(arg0: Object).void) + ).void + end + def initialize(initial_frozen_hash, definition_class, &on_new_definition); end + + sig { params(name: T.nilable(String), definition: Object).returns(Object) } + def []=(name, definition); end + + sig { params(name: T.nilable(String), definition: Object).returns(Object) } + def store(name, definition); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/illegal_call_tracer.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/illegal_call_tracer.rbi new file mode 100644 index 00000000..866c272d --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/illegal_call_tracer.rbi @@ -0,0 +1,17 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::IllegalCallTracer + extend T::Sig + + sig { params(illegal_calls: T::Hash[String, Object]).returns(T::Hash[String, Object]) } + def self.frozen_validated_illegal_calls(illegal_calls); end + + sig { params(illegal_calls: T::Hash[String, Object]).void } + def initialize(illegal_calls); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def enable(&block); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def disable_temporarily(&block); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/inbound_implementation.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/inbound_implementation.rbi new file mode 100644 index 00000000..c35bc929 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/inbound_implementation.rbi @@ -0,0 +1,21 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::InboundImplementation < Temporalio::Worker::Interceptor::Workflow::Inbound + extend T::Sig + + sig { params(instance: Temporalio::Internal::Worker::WorkflowInstance).void } + def initialize(instance); end + + sig do + params( + name: String, + input: T.any( + Temporalio::Worker::Interceptor::Workflow::HandleSignalInput, + Temporalio::Worker::Interceptor::Workflow::HandleQueryInput, + Temporalio::Worker::Interceptor::Workflow::HandleUpdateInput + ), + to_invoke: T.nilable(T.any(Symbol, Proc)) + ).returns(T.nilable(Object)) + end + def invoke_handler(name, input, to_invoke: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/nexus_client.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/nexus_client.rbi new file mode 100644 index 00000000..a5436a3b --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/nexus_client.rbi @@ -0,0 +1,47 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::NexusClient < Temporalio::Workflow::NexusClient + extend T::Sig + + sig { returns(String) } + attr_reader :endpoint + + sig { returns(String) } + attr_reader :service + + sig do + params( + endpoint: T.any(Symbol, String), + service: T.any(Symbol, String), + outbound: Object + ).void + end + def initialize(endpoint:, service:, outbound:); end + + sig do + params( + operation: T.any(Symbol, String), + arg: T.nilable(Object), + schedule_to_close_timeout: T.nilable(T.any(Integer, Float)), + schedule_to_start_timeout: T.nilable(T.any(Integer, Float)), + start_to_close_timeout: T.nilable(T.any(Integer, Float)), + cancellation_type: Integer, + summary: T.nilable(String), + cancellation: Temporalio::Cancellation, + arg_hint: T.nilable(Object), + result_hint: T.nilable(Object) + ).returns(Temporalio::Workflow::NexusOperationHandle) + end + def start_operation( + operation, + arg, + schedule_to_close_timeout: T.unsafe(nil), + schedule_to_start_timeout: T.unsafe(nil), + start_to_close_timeout: T.unsafe(nil), + cancellation_type: T.unsafe(nil), + summary: T.unsafe(nil), + cancellation: T.unsafe(nil), + arg_hint: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/nexus_operation_handle.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/nexus_operation_handle.rbi new file mode 100644 index 00000000..0054673a --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/nexus_operation_handle.rbi @@ -0,0 +1,19 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::NexusOperationHandle < Temporalio::Workflow::NexusOperationHandle + extend T::Sig + + sig do + params( + operation_token: T.nilable(String), + instance: Temporalio::Internal::Worker::WorkflowInstance, + cancellation: Temporalio::Cancellation, + cancel_callback_key: Object, + result_hint: T.nilable(Object) + ).void + end + def initialize(operation_token:, instance:, cancellation:, cancel_callback_key:, result_hint:); end + + sig { params(resolution: Object).void } + def _resolve(resolution); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/outbound_implementation.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/outbound_implementation.rbi new file mode 100644 index 00000000..e0c684bf --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/outbound_implementation.rbi @@ -0,0 +1,43 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::OutboundImplementation < Temporalio::Worker::Interceptor::Workflow::Outbound + extend T::Sig + + sig { params(instance: Temporalio::Internal::Worker::WorkflowInstance).void } + def initialize(instance); end + + sig do + params( + local: T::Boolean, + cancellation: Temporalio::Cancellation, + result_hint: T.nilable(Object), + block: T.proc.params(arg0: T.nilable(Object)).returns(Integer) + ).returns(T.nilable(Object)) + end + def execute_activity_with_local_backoffs(local:, cancellation:, result_hint:, &block); end + + sig do + params( + local: T::Boolean, + cancellation: Temporalio::Cancellation, + last_local_backoff: T.nilable(Object), + result_hint: T.nilable(Object), + block: T.proc.params(arg0: T.nilable(Object)).returns(Integer) + ).returns(T.nilable(Object)) + end + def execute_activity_once(local:, cancellation:, last_local_backoff:, result_hint:, &block); end + + sig do + params( + id: String, + run_id: T.nilable(String), + child: T::Boolean, + signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String), + args: T::Array[T.nilable(Object)], + cancellation: Temporalio::Cancellation, + arg_hints: T.nilable(T::Array[Object]), + headers: T::Hash[String, T.nilable(Object)] + ).void + end + def _signal_external_workflow(id:, run_id:, child:, signal:, args:, cancellation:, arg_hints:, headers:); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/replay_safe_logger.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/replay_safe_logger.rbi new file mode 100644 index 00000000..88288504 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/replay_safe_logger.rbi @@ -0,0 +1,11 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeLogger < Temporalio::ScopedLogger + extend T::Sig + + sig { params(logger: Logger, instance: Temporalio::Internal::Worker::WorkflowInstance).void } + def initialize(logger:, instance:); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def replay_safety_disabled(&block); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/replay_safe_metric.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/replay_safe_metric.rbi new file mode 100644 index 00000000..c281621a --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/replay_safe_metric.rbi @@ -0,0 +1,15 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeMetric < Temporalio::Metric + extend T::Sig + + sig { params(obj: Temporalio::Metric).void } + def initialize(obj); end +end + +class Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeMetric::Meter < Temporalio::Metric::Meter + extend T::Sig + + sig { params(obj: Temporalio::Metric::Meter).void } + def initialize(obj); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_instance/scheduler.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_instance/scheduler.rbi new file mode 100644 index 00000000..74bdb861 --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_instance/scheduler.rbi @@ -0,0 +1,36 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowInstance::Scheduler + extend T::Sig + + sig { params(instance: Temporalio::Internal::Worker::WorkflowInstance).void } + def initialize(instance); end + + sig { returns(Temporalio::Internal::Worker::WorkflowInstance::Context) } + def context; end + + sig { void } + def run_until_all_yielded; end + + sig do + type_parameters(:T) + .params(cancellation: T.nilable(Temporalio::Cancellation), block: T.proc.returns(T.type_parameter(:T))) + .returns(T.type_parameter(:T)) + end + def wait_condition(cancellation:, &block); end + + sig { returns(String) } + def stack_trace; end + + sig do + type_parameters(:T) + .params( + duration: T.nilable(T.any(Integer, Float)), + exception_class: T.class_of(Exception), + exception_arguments: T.nilable(Object), + block: T.proc.returns(T.type_parameter(:T)) + ) + .returns(T.type_parameter(:T)) + end + def timeout_after(duration, exception_class, *exception_arguments, &block); end +end diff --git a/temporalio/rbi/temporalio/internal/worker/workflow_worker.rbi b/temporalio/rbi/temporalio/internal/worker/workflow_worker.rbi new file mode 100644 index 00000000..f45ebfcd --- /dev/null +++ b/temporalio/rbi/temporalio/internal/worker/workflow_worker.rbi @@ -0,0 +1,192 @@ +# typed: true + +class Temporalio::Internal::Worker::WorkflowWorker + extend T::Sig + + sig do + params( + workflows: T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)], + should_enforce_versioning_behavior: T::Boolean + ).returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info]) + end + def self.workflow_definitions(workflows, should_enforce_versioning_behavior:); end + + sig do + params( + workflow_failure_exception_types: T::Array[T.class_of(Exception)], + workflow_definitions: T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info] + ).returns([T::Boolean, T::Array[String]]) + end + def self.bridge_workflow_failure_exception_type_options(workflow_failure_exception_types:, workflow_definitions:); end + + sig do + params( + bridge_worker: Temporalio::Internal::Bridge::Worker, + namespace: String, + task_queue: String, + workflow_definitions: T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info], + workflow_executor: Temporalio::Worker::WorkflowExecutor, + logger: Logger, + data_converter: Temporalio::Converters::DataConverter, + metric_meter: Temporalio::Metric::Meter, + workflow_interceptors: T::Array[Temporalio::Worker::Interceptor::Workflow], + disable_eager_activity_execution: T::Boolean, + illegal_workflow_calls: T.nilable(T::Hash[String, Object]), + workflow_failure_exception_types: T::Array[T.class_of(Exception)], + workflow_payload_codec_thread_pool: T.nilable(Temporalio::Worker::ThreadPool), + unsafe_workflow_io_enabled: T::Boolean, + debug_mode: T::Boolean, + assert_valid_local_activity: T.proc.params(arg0: String).void, + on_eviction: T.nilable(T.proc.params(arg0: String, arg1: Object).void) + ).void + end + def initialize( + bridge_worker:, + namespace:, + task_queue:, + workflow_definitions:, + workflow_executor:, + logger:, + data_converter:, + metric_meter:, + workflow_interceptors:, + disable_eager_activity_execution:, + illegal_workflow_calls:, + workflow_failure_exception_types:, + workflow_payload_codec_thread_pool:, + unsafe_workflow_io_enabled:, + debug_mode:, + assert_valid_local_activity:, + on_eviction: T.unsafe(nil) + ); end + + sig do + params( + runner: Temporalio::Internal::Worker::MultiRunner, + activation: Object, + decoded: T::Boolean + ).void + end + def handle_activation(runner:, activation:, decoded:); end + + sig do + params( + runner: Temporalio::Internal::Worker::MultiRunner, + activation_completion: Object, + encoded: T::Boolean, + completion_complete_queue: Queue + ).void + end + def handle_activation_complete(runner:, activation_completion:, encoded:, completion_complete_queue:); end + + sig { void } + def on_shutdown_complete; end + + private + + sig { params(runner: Temporalio::Internal::Worker::MultiRunner, activation: Object).void } + def decode_activation(runner, activation); end + + sig { params(runner: Temporalio::Internal::Worker::MultiRunner, activation_completion: Object).void } + def encode_activation_completion(runner, activation_completion); end + + sig { params(payload_or_payloads: Object, block: T.proc.params(arg0: Object).returns(Object)).void } + def apply_codec_on_payload_visit(payload_or_payloads, &block); end +end + +class Temporalio::Internal::Worker::WorkflowWorker::State + extend T::Sig + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info]) } + attr_reader :workflow_definitions + + sig { returns(Temporalio::Internal::Bridge::Worker) } + attr_reader :bridge_worker + + sig { returns(Logger) } + attr_reader :logger + + sig { returns(Temporalio::Metric::Meter) } + attr_reader :metric_meter + + sig { returns(Temporalio::Converters::DataConverter) } + attr_reader :data_converter + + sig { returns(T.nilable(Float)) } + attr_reader :deadlock_timeout + + sig { returns(T::Hash[String, Object]) } + attr_reader :illegal_calls + + sig { returns(String) } + attr_reader :namespace + + sig { returns(String) } + attr_reader :task_queue + + sig { returns(T::Boolean) } + attr_reader :disable_eager_activity_execution + + sig { returns(T::Array[Temporalio::Worker::Interceptor::Workflow]) } + attr_reader :workflow_interceptors + + sig { returns(T::Array[T.class_of(Exception)]) } + attr_reader :workflow_failure_exception_types + + sig { returns(T::Boolean) } + attr_reader :unsafe_workflow_io_enabled + + sig { returns(T.proc.params(arg0: String).void) } + attr_reader :assert_valid_local_activity + + sig { params(on_eviction: T.proc.params(arg0: String, arg1: Object).void).returns(T.proc.params(arg0: String, arg1: Object).void) } + attr_writer :on_eviction + + sig do + params( + workflow_definitions: T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info], + bridge_worker: Temporalio::Internal::Bridge::Worker, + logger: Logger, + metric_meter: Temporalio::Metric::Meter, + data_converter: Temporalio::Converters::DataConverter, + deadlock_timeout: T.nilable(Float), + illegal_calls: T::Hash[String, Object], + namespace: String, + task_queue: String, + disable_eager_activity_execution: T::Boolean, + workflow_interceptors: T::Array[Temporalio::Worker::Interceptor::Workflow], + workflow_failure_exception_types: T::Array[T.class_of(Exception)], + unsafe_workflow_io_enabled: T::Boolean, + assert_valid_local_activity: T.proc.params(arg0: String).void + ).void + end + def initialize( + workflow_definitions:, + bridge_worker:, + logger:, + metric_meter:, + data_converter:, + deadlock_timeout:, + illegal_calls:, + namespace:, + task_queue:, + disable_eager_activity_execution:, + workflow_interceptors:, + workflow_failure_exception_types:, + unsafe_workflow_io_enabled:, + assert_valid_local_activity: + ); end + + sig do + type_parameters(:T) + .params(run_id: String, block: T.proc.returns(T.type_parameter(:T))) + .returns(T.type_parameter(:T)) + end + def get_or_create_running_workflow(run_id, &block); end + + sig { params(run_id: String, cache_remove_job: Object).void } + def evict_running_workflow(run_id, cache_remove_job); end + + sig { void } + def evict_all; end +end diff --git a/temporalio/rbi/temporalio/metric.rbi b/temporalio/rbi/temporalio/metric.rbi new file mode 100644 index 00000000..1f3b7fda --- /dev/null +++ b/temporalio/rbi/temporalio/metric.rbi @@ -0,0 +1,59 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Metric + sig do + params( + value: Numeric, + additional_attributes: T.nilable(T::Hash[T.any(String, Symbol), T.any(String, Integer, Float, T::Boolean)]) + ).void + end + def record(value, additional_attributes: nil); end + + sig do + params( + additional_attributes: T::Hash[T.any(String, Symbol), T.any(String, Integer, Float, T::Boolean)] + ).returns(Temporalio::Metric) + end + def with_additional_attributes(additional_attributes); end + + sig { returns(Symbol) } + def metric_type; end + + sig { returns(String) } + def name; end + + sig { returns(T.nilable(String)) } + def description; end + + sig { returns(T.nilable(String)) } + def unit; end + + sig { returns(Symbol) } + def value_type; end +end + +class Temporalio::Metric::Meter + sig { returns(Temporalio::Metric::Meter) } + def self.null; end + + sig do + params( + metric_type: Symbol, + name: String, + description: T.nilable(String), + unit: T.nilable(String), + value_type: Symbol + ).returns(Temporalio::Metric) + end + def create_metric(metric_type, name, description: nil, unit: nil, value_type: :integer); end + + sig do + params( + additional_attributes: T::Hash[T.any(String, Symbol), T.any(String, Integer, Float, T::Boolean)] + ).returns(Temporalio::Metric::Meter) + end + def with_additional_attributes(additional_attributes); end +end diff --git a/temporalio/rbi/temporalio/priority.rbi b/temporalio/rbi/temporalio/priority.rbi new file mode 100644 index 00000000..e0dcd6be --- /dev/null +++ b/temporalio/rbi/temporalio/priority.rbi @@ -0,0 +1,41 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Priority < ::Data + sig do + params( + priority_key: T.nilable(Integer), + fairness_key: T.nilable(String), + fairness_weight: T.nilable(Float) + ).void + end + def initialize(priority_key: nil, fairness_key: nil, fairness_weight: nil); end + + sig { returns(Temporalio::Priority) } + def self.default; end + + sig { returns(T.nilable(Integer)) } + def priority_key; end + + sig { returns(T.nilable(String)) } + def fairness_key; end + + sig { returns(T.nilable(Numeric)) } + def fairness_weight; end + + sig { returns(T::Boolean) } + def empty?; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::Priority) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + + sig { params(args: T.untyped).returns(Temporalio::Priority) } + def new(*args); end + end +end diff --git a/temporalio/rbi/temporalio/retry_policy.rbi b/temporalio/rbi/temporalio/retry_policy.rbi new file mode 100644 index 00000000..33d3dd91 --- /dev/null +++ b/temporalio/rbi/temporalio/retry_policy.rbi @@ -0,0 +1,43 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::RetryPolicy < ::Data + sig do + params( + initial_interval: T.any(Integer, Float), + backoff_coefficient: T.any(Integer, Float), + max_interval: T.nilable(T.any(Integer, Float)), + max_attempts: Integer, + non_retryable_error_types: T.nilable(T::Array[String]) + ).void + end + def initialize(initial_interval: 1.0, backoff_coefficient: 2.0, max_interval: nil, max_attempts: 0, non_retryable_error_types: nil); end + + sig { returns(T.any(Integer, Float)) } + def initial_interval; end + + sig { returns(T.any(Integer, Float)) } + def backoff_coefficient; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def max_interval; end + + sig { returns(Integer) } + def max_attempts; end + + sig { returns(T.nilable(T::Array[String])) } + def non_retryable_error_types; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::RetryPolicy) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + + sig { params(args: T.untyped).returns(Temporalio::RetryPolicy) } + def new(*args); end + end +end diff --git a/temporalio/rbi/temporalio/runtime.rbi b/temporalio/rbi/temporalio/runtime.rbi new file mode 100644 index 00000000..d22f88c7 --- /dev/null +++ b/temporalio/rbi/temporalio/runtime.rbi @@ -0,0 +1,188 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Runtime + extend T::Sig + + sig { returns(Temporalio::Metric::Meter) } + attr_reader :metric_meter + + sig { params(telemetry: Temporalio::Runtime::TelemetryOptions, worker_heartbeat_interval: T.nilable(Float)).void } + def initialize(telemetry: T.unsafe(nil), worker_heartbeat_interval: T.unsafe(nil)); end + + class << self + extend T::Sig + + sig { returns(Temporalio::Runtime) } + def default; end + + sig { params(runtime: Temporalio::Runtime).void } + def default=(runtime); end + end +end + +class Temporalio::Runtime::TelemetryOptions < ::Data + extend T::Sig + + sig { returns(T.nilable(Temporalio::Runtime::LoggingOptions)) } + def logging; end + + sig { returns(T.nilable(Temporalio::Runtime::MetricsOptions)) } + def metrics; end + + sig { params(logging: T.nilable(Temporalio::Runtime::LoggingOptions), metrics: T.nilable(Temporalio::Runtime::MetricsOptions)).void } + def initialize(logging: T.unsafe(nil), metrics: T.unsafe(nil)); end +end + +class Temporalio::Runtime::LoggingOptions < ::Data + extend T::Sig + + sig { returns(T.any(Temporalio::Runtime::LoggingFilterOptions, String)) } + def log_filter; end + + sig { params(log_filter: T.any(Temporalio::Runtime::LoggingFilterOptions, String)).void } + def initialize(log_filter: T.unsafe(nil)); end +end + +class Temporalio::Runtime::LoggingFilterOptions < ::Data + extend T::Sig + + sig { returns(String) } + def core_level; end + + sig { returns(String) } + def other_level; end + + sig { params(core_level: String, other_level: String).void } + def initialize(core_level: T.unsafe(nil), other_level: T.unsafe(nil)); end +end + +class Temporalio::Runtime::MetricsOptions < ::Data + extend T::Sig + + sig { returns(T.nilable(Temporalio::Runtime::OpenTelemetryMetricsOptions)) } + def opentelemetry; end + + sig { returns(T.nilable(Temporalio::Runtime::PrometheusMetricsOptions)) } + def prometheus; end + + sig { returns(T.nilable(Temporalio::Runtime::MetricBuffer)) } + def buffer; end + + sig { returns(T::Boolean) } + def attach_service_name; end + + sig { returns(T.nilable(T::Hash[String, String])) } + def global_tags; end + + sig { returns(T.nilable(String)) } + def metric_prefix; end + + sig do + params( + opentelemetry: T.nilable(Temporalio::Runtime::OpenTelemetryMetricsOptions), + prometheus: T.nilable(Temporalio::Runtime::PrometheusMetricsOptions), + buffer: T.nilable(Temporalio::Runtime::MetricBuffer), + attach_service_name: T::Boolean, + global_tags: T.nilable(T::Hash[String, String]), + metric_prefix: T.nilable(String) + ).void + end + def initialize( + opentelemetry: T.unsafe(nil), + prometheus: T.unsafe(nil), + buffer: T.unsafe(nil), + attach_service_name: T.unsafe(nil), + global_tags: T.unsafe(nil), + metric_prefix: T.unsafe(nil) + ); end +end + +class Temporalio::Runtime::OpenTelemetryMetricsOptions < ::Data + extend T::Sig + + sig { returns(String) } + def url; end + + sig { returns(T.nilable(T::Hash[String, String])) } + def headers; end + + sig { returns(T.nilable(Numeric)) } + def metric_periodicity; end + + sig { returns(Integer) } + def metric_temporality; end + + sig { returns(T::Boolean) } + def durations_as_seconds; end + + sig { returns(T::Boolean) } + def http; end + + sig { returns(T.nilable(T::Hash[String, T::Array[Numeric]])) } + def histogram_bucket_overrides; end + + sig do + params( + url: String, + headers: T.nilable(T::Hash[String, String]), + metric_periodicity: T.nilable(Float), + metric_temporality: Integer, + durations_as_seconds: T::Boolean, + http: T::Boolean, + histogram_bucket_overrides: T.nilable(T::Hash[String, T::Array[Numeric]]) + ).void + end + def initialize( + url:, + headers: T.unsafe(nil), + metric_periodicity: T.unsafe(nil), + metric_temporality: T.unsafe(nil), + durations_as_seconds: T.unsafe(nil), + http: T.unsafe(nil), + histogram_bucket_overrides: T.unsafe(nil) + ); end + + module MetricTemporality + CUMULATIVE = T.let(T.unsafe(nil), Integer) + DELTA = T.let(T.unsafe(nil), Integer) + end +end + +class Temporalio::Runtime::PrometheusMetricsOptions < ::Data + extend T::Sig + + sig { returns(String) } + def bind_address; end + + sig { returns(T::Boolean) } + def counters_total_suffix; end + + sig { returns(T::Boolean) } + def unit_suffix; end + + sig { returns(T::Boolean) } + def durations_as_seconds; end + + sig { returns(T.nilable(T::Hash[String, T::Array[Numeric]])) } + def histogram_bucket_overrides; end + + sig do + params( + bind_address: String, + counters_total_suffix: T::Boolean, + unit_suffix: T::Boolean, + durations_as_seconds: T::Boolean, + histogram_bucket_overrides: T.nilable(T::Hash[String, T::Array[Numeric]]) + ).void + end + def initialize( + bind_address:, + counters_total_suffix: T.unsafe(nil), + unit_suffix: T.unsafe(nil), + durations_as_seconds: T.unsafe(nil), + histogram_bucket_overrides: T.unsafe(nil) + ); end +end diff --git a/temporalio/rbi/temporalio/runtime/metric_buffer.rbi b/temporalio/rbi/temporalio/runtime/metric_buffer.rbi new file mode 100644 index 00000000..a30fa404 --- /dev/null +++ b/temporalio/rbi/temporalio/runtime/metric_buffer.rbi @@ -0,0 +1,48 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Runtime::MetricBuffer + extend T::Sig + + sig { params(buffer_size: Integer, duration_format: Symbol).void } + def initialize(buffer_size, duration_format: T.unsafe(nil)); end + + sig { returns(T::Array[Temporalio::Runtime::MetricBuffer::Update]) } + def retrieve_updates; end + + module DurationFormat + MILLISECONDS = T.let(T.unsafe(nil), Symbol) + SECONDS = T.let(T.unsafe(nil), Symbol) + end +end + +class Temporalio::Runtime::MetricBuffer::Update < ::Data + extend T::Sig + + sig { returns(Temporalio::Runtime::MetricBuffer::Metric) } + def metric; end + + sig { returns(T.any(Integer, Float)) } + def value; end + + sig { returns(T::Hash[String, T.any(String, Integer, Float, T::Boolean)]) } + def attributes; end +end + +class Temporalio::Runtime::MetricBuffer::Metric < ::Data + extend T::Sig + + sig { returns(String) } + def name; end + + sig { returns(T.nilable(String)) } + def description; end + + sig { returns(T.nilable(String)) } + def unit; end + + sig { returns(Symbol) } + def kind; end +end diff --git a/temporalio/rbi/temporalio/scoped_logger.rbi b/temporalio/rbi/temporalio/scoped_logger.rbi new file mode 100644 index 00000000..246ea743 --- /dev/null +++ b/temporalio/rbi/temporalio/scoped_logger.rbi @@ -0,0 +1,53 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::ScopedLogger < ::SimpleDelegator + sig { params(obj: ::Logger).void } + def initialize(obj); end + + sig { returns(T.nilable(Proc)) } + attr_accessor :scoped_values_getter + + sig { returns(T::Boolean) } + attr_accessor :disable_scoped_values + + sig { params(severity: T.nilable(Integer), message: T.nilable(Object), progname: T.nilable(Object)).void } + def add(severity, message = nil, progname = nil); end + + sig { params(severity: T.nilable(Integer), message: T.nilable(Object), progname: T.nilable(Object)).void } + def log(severity, message = nil, progname = nil); end + + sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void } + def debug(progname = nil, &blk); end + + sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void } + def info(progname = nil, &blk); end + + sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void } + def warn(progname = nil, &blk); end + + sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void } + def error(progname = nil, &blk); end + + sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void } + def fatal(progname = nil, &blk); end + + sig { params(progname: T.nilable(Object), blk: T.nilable(T.proc.returns(Object))).void } + def unknown(progname = nil, &blk); end +end + +class Temporalio::ScopedLogger::LogMessage + sig { params(message: Object, scoped_values: Object).void } + def initialize(message, scoped_values); end + + sig { returns(Object) } + attr_reader :message + + sig { returns(Object) } + attr_reader :scoped_values + + sig { returns(String) } + def inspect; end +end diff --git a/temporalio/rbi/temporalio/search_attributes.rbi b/temporalio/rbi/temporalio/search_attributes.rbi new file mode 100644 index 00000000..343fb97a --- /dev/null +++ b/temporalio/rbi/temporalio/search_attributes.rbi @@ -0,0 +1,97 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::SearchAttributes + sig { params(existing: T.nilable(T.any(Temporalio::SearchAttributes, T::Hash[Temporalio::SearchAttributes::Key, Object]))).void } + def initialize(existing = nil); end + + sig { params(key: T.any(Temporalio::SearchAttributes::Key, String, Symbol), value: T.nilable(Object)).void } + def []=(key, value); end + + sig { params(key: Temporalio::SearchAttributes::Key).returns(T.nilable(Object)) } + def [](key); end + + sig { params(key: T.any(Temporalio::SearchAttributes::Key, String, Symbol)).void } + def delete(key); end + + sig { params(block: T.proc.params(key: Temporalio::SearchAttributes::Key, value: Object).void).returns(Temporalio::SearchAttributes) } + def each(&block); end + + sig { returns(T::Hash[Temporalio::SearchAttributes::Key, Object]) } + def to_h; end + + sig { returns(Temporalio::SearchAttributes) } + def dup; end + + sig { returns(T::Boolean) } + def empty?; end + + sig { returns(Integer) } + def length; end + + sig { returns(Integer) } + def size; end + + sig { params(updates: Temporalio::SearchAttributes::Update).returns(Temporalio::SearchAttributes) } + def update(*updates); end + + sig { params(updates: Temporalio::SearchAttributes::Update).void } + def update!(*updates); end + + sig { params(other: Temporalio::SearchAttributes).returns(T::Boolean) } + def ==(other); end +end + +class Temporalio::SearchAttributes::Key + sig { params(name: String, type: Integer).void } + def initialize(name, type); end + + sig { returns(String) } + attr_reader :name + + sig { returns(Integer) } + attr_reader :type + + sig { params(value: Object).void } + def validate_value(value); end + + sig { params(value: Object).returns(Temporalio::SearchAttributes::Update) } + def value_set(value); end + + sig { returns(Temporalio::SearchAttributes::Update) } + def value_unset; end + + sig { params(other: T.anything).returns(T::Boolean) } + def ==(other); end + + sig { params(other: T.anything).returns(T::Boolean) } + def eql?(other); end + + sig { returns(Integer) } + def hash; end +end + +class Temporalio::SearchAttributes::Update + sig { params(key: Temporalio::SearchAttributes::Key, value: T.nilable(Object)).void } + def initialize(key, value); end + + sig { returns(Temporalio::SearchAttributes::Key) } + attr_reader :key + + sig { returns(T.nilable(Object)) } + attr_reader :value +end + +module Temporalio::SearchAttributes::IndexedValueType + TEXT = T.let(T.unsafe(nil), Integer) + KEYWORD = T.let(T.unsafe(nil), Integer) + INTEGER = T.let(T.unsafe(nil), Integer) + FLOAT = T.let(T.unsafe(nil), Integer) + BOOLEAN = T.let(T.unsafe(nil), Integer) + TIME = T.let(T.unsafe(nil), Integer) + KEYWORD_LIST = T.let(T.unsafe(nil), Integer) + PROTO_NAMES = T.let(T.unsafe(nil), T::Hash[Integer, String]) + PROTO_VALUES = T.let(T.unsafe(nil), T::Hash[String, Integer]) +end diff --git a/temporalio/rbi/temporalio/simple_plugin.rbi b/temporalio/rbi/temporalio/simple_plugin.rbi new file mode 100644 index 00000000..96c0ea13 --- /dev/null +++ b/temporalio/rbi/temporalio/simple_plugin.rbi @@ -0,0 +1,44 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::SimplePlugin + include Temporalio::Client::Plugin + include Temporalio::Worker::Plugin + + extend T::Sig + + sig { returns(Temporalio::SimplePlugin::Options) } + attr_reader :options + + sig do + params( + name: String, + data_converter: T.nilable(T.any(Temporalio::Converters::DataConverter, T.proc.params(arg0: Temporalio::Converters::DataConverter).returns(Temporalio::Converters::DataConverter))), + client_interceptors: T.nilable(T.any(T::Array[Temporalio::Client::Interceptor], T.proc.params(arg0: T::Array[Temporalio::Client::Interceptor]).returns(T::Array[Temporalio::Client::Interceptor]))), + activities: T.nilable(T.any(T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)], T.proc.params(arg0: T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)]).returns(T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)]))), + workflows: T.nilable(T.any(T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)], T.proc.params(arg0: T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)]).returns(T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)]))), + worker_interceptors: T.nilable(T.any(T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)], T.proc.params(arg0: T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)]).returns(T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)]))), + workflow_failure_exception_types: T.nilable(T.any(T::Array[String], T.proc.params(arg0: T::Array[String]).returns(T::Array[String]))), + run_context: T.nilable(T.proc.params(arg0: T.any(Temporalio::Worker::Plugin::RunWorkerOptions, Temporalio::Worker::Plugin::WithWorkflowReplayWorkerOptions), arg1: T.proc.params(arg0: T.any(Temporalio::Worker::Plugin::RunWorkerOptions, Temporalio::Worker::Plugin::WithWorkflowReplayWorkerOptions)).returns(T.anything)).returns(T.anything)) + ).void + end + def initialize( + name:, + data_converter: T.unsafe(nil), + client_interceptors: T.unsafe(nil), + activities: T.unsafe(nil), + workflows: T.unsafe(nil), + worker_interceptors: T.unsafe(nil), + workflow_failure_exception_types: T.unsafe(nil), + run_context: T.unsafe(nil) + ); end +end + +class Temporalio::SimplePlugin::Options + extend T::Sig + + sig { returns(String) } + def name; end +end diff --git a/temporalio/rbi/temporalio/testing.rbi b/temporalio/rbi/temporalio/testing.rbi new file mode 100644 index 00000000..346ce1d6 --- /dev/null +++ b/temporalio/rbi/temporalio/testing.rbi @@ -0,0 +1,6 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Testing; end diff --git a/temporalio/rbi/temporalio/testing/activity_environment.rbi b/temporalio/rbi/temporalio/testing/activity_environment.rbi new file mode 100644 index 00000000..2ff3781e --- /dev/null +++ b/temporalio/rbi/temporalio/testing/activity_environment.rbi @@ -0,0 +1,46 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Testing::ActivityEnvironment + extend T::Sig + + sig { returns(Temporalio::Activity::Info) } + def self.default_info; end + + sig do + params( + info: Temporalio::Activity::Info, + on_heartbeat: T.nilable(Proc), + cancellation: Temporalio::Cancellation, + on_cancellation_details: T.nilable(Proc), + worker_shutdown_cancellation: Temporalio::Cancellation, + payload_converter: Temporalio::Converters::PayloadConverter, + logger: Logger, + activity_executors: T::Hash[Symbol, Temporalio::Worker::ActivityExecutor], + metric_meter: T.nilable(Temporalio::Metric::Meter), + client: T.nilable(Temporalio::Client) + ).void + end + def initialize( + info: T.unsafe(nil), + on_heartbeat: T.unsafe(nil), + cancellation: T.unsafe(nil), + on_cancellation_details: T.unsafe(nil), + worker_shutdown_cancellation: T.unsafe(nil), + payload_converter: T.unsafe(nil), + logger: T.unsafe(nil), + activity_executors: T.unsafe(nil), + metric_meter: T.unsafe(nil), + client: T.unsafe(nil) + ); end + + sig do + params( + activity: T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info), + args: T.nilable(Object) + ).returns(T.anything) + end + def run(activity, *args); end +end diff --git a/temporalio/rbi/temporalio/testing/workflow_environment.rbi b/temporalio/rbi/temporalio/testing/workflow_environment.rbi new file mode 100644 index 00000000..6b1550d0 --- /dev/null +++ b/temporalio/rbi/temporalio/testing/workflow_environment.rbi @@ -0,0 +1,119 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Testing::WorkflowEnvironment + extend T::Sig + + sig { returns(Temporalio::Client) } + attr_reader :client + + sig { params(client: Temporalio::Client).void } + def initialize(client); end + + sig { void } + def shutdown; end + + sig { returns(T::Boolean) } + def supports_time_skipping?; end + + sig { params(duration: T.any(Integer, Float)).void } + def sleep(duration); end + + sig { returns(Time) } + def current_time; end + + sig { params(name: String, task_queue: String).returns(Temporalio::Api::Nexus::V1::Endpoint) } + def create_nexus_endpoint(name:, task_queue:); end + + sig { params(endpoint: Temporalio::Api::Nexus::V1::Endpoint).returns(NilClass) } + def delete_nexus_endpoint(endpoint); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def auto_time_skipping_disabled(&block); end + + class << self + extend T::Sig + + sig do + type_parameters(:T) + .params( + namespace: String, + data_converter: Temporalio::Converters::DataConverter, + interceptors: T::Array[Temporalio::Client::Interceptor], + logger: Logger, + default_workflow_query_reject_condition: T.nilable(Integer), + ip: String, + port: T.nilable(Integer), + ui: T::Boolean, + ui_port: T.nilable(Integer), + search_attributes: T::Array[Temporalio::SearchAttributes::Key], + runtime: Temporalio::Runtime, + dev_server_existing_path: T.nilable(String), + dev_server_database_filename: T.nilable(String), + dev_server_log_format: String, + dev_server_log_level: String, + dev_server_download_version: String, + dev_server_download_dest_dir: T.nilable(String), + dev_server_extra_args: T::Array[String], + dev_server_download_ttl: T.nilable(Float), + block: T.nilable(T.proc.params(arg0: Temporalio::Testing::WorkflowEnvironment).returns(T.type_parameter(:T))) + ).returns(T.any(Temporalio::Testing::WorkflowEnvironment, T.type_parameter(:T))) + end + def start_local( + namespace: T.unsafe(nil), + data_converter: T.unsafe(nil), + interceptors: T.unsafe(nil), + logger: T.unsafe(nil), + default_workflow_query_reject_condition: T.unsafe(nil), + ip: T.unsafe(nil), + port: T.unsafe(nil), + ui: T.unsafe(nil), + ui_port: T.unsafe(nil), + search_attributes: T.unsafe(nil), + runtime: T.unsafe(nil), + dev_server_existing_path: T.unsafe(nil), + dev_server_database_filename: T.unsafe(nil), + dev_server_log_format: T.unsafe(nil), + dev_server_log_level: T.unsafe(nil), + dev_server_download_version: T.unsafe(nil), + dev_server_download_dest_dir: T.unsafe(nil), + dev_server_extra_args: T.unsafe(nil), + dev_server_download_ttl: T.unsafe(nil), + &block + ); end + + sig do + type_parameters(:T) + .params( + data_converter: Temporalio::Converters::DataConverter, + interceptors: T::Array[Temporalio::Client::Interceptor], + logger: Logger, + default_workflow_query_reject_condition: T.nilable(Integer), + port: T.nilable(Integer), + runtime: Temporalio::Runtime, + test_server_existing_path: T.nilable(String), + test_server_download_version: String, + test_server_download_dest_dir: T.nilable(String), + test_server_extra_args: T::Array[String], + test_server_download_ttl: T.nilable(Float), + block: T.nilable(T.proc.params(arg0: Temporalio::Testing::WorkflowEnvironment).returns(T.type_parameter(:T))) + ).returns(T.any(Temporalio::Testing::WorkflowEnvironment, T.type_parameter(:T))) + end + def start_time_skipping( + data_converter: T.unsafe(nil), + interceptors: T.unsafe(nil), + logger: T.unsafe(nil), + default_workflow_query_reject_condition: T.unsafe(nil), + port: T.unsafe(nil), + runtime: T.unsafe(nil), + test_server_existing_path: T.unsafe(nil), + test_server_download_version: T.unsafe(nil), + test_server_download_dest_dir: T.unsafe(nil), + test_server_extra_args: T.unsafe(nil), + test_server_download_ttl: T.unsafe(nil), + &block + ); end + end +end diff --git a/temporalio/rbi/temporalio/version.rbi b/temporalio/rbi/temporalio/version.rbi new file mode 100644 index 00000000..518f4376 --- /dev/null +++ b/temporalio/rbi/temporalio/version.rbi @@ -0,0 +1,5 @@ +# typed: true + +module Temporalio + VERSION = T.let(T.unsafe(nil), String) +end diff --git a/temporalio/rbi/temporalio/versioning_override.rbi b/temporalio/rbi/temporalio/versioning_override.rbi new file mode 100644 index 00000000..402f0e0e --- /dev/null +++ b/temporalio/rbi/temporalio/versioning_override.rbi @@ -0,0 +1,16 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::VersioningOverride; end + +class Temporalio::VersioningOverride::Pinned < ::Temporalio::VersioningOverride + sig { params(version: Temporalio::WorkerDeploymentVersion).void } + def initialize(version); end + + sig { returns(Temporalio::WorkerDeploymentVersion) } + attr_reader :version +end + +class Temporalio::VersioningOverride::AutoUpgrade < ::Temporalio::VersioningOverride; end diff --git a/temporalio/rbi/temporalio/worker.rbi b/temporalio/rbi/temporalio/worker.rbi new file mode 100644 index 00000000..dd75a82f --- /dev/null +++ b/temporalio/rbi/temporalio/worker.rbi @@ -0,0 +1,240 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker + extend T::Sig + + sig { returns(Options) } + attr_reader :options + + sig do + params( + client: Temporalio::Client, + task_queue: String, + activities: T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)], + workflows: T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)], + tuner: Temporalio::Worker::Tuner, + activity_executors: T::Hash[Symbol, Temporalio::Worker::ActivityExecutor], + workflow_executor: Temporalio::Worker::WorkflowExecutor, + plugins: T::Array[Temporalio::Worker::Plugin], + interceptors: T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)], + identity: T.nilable(String), + logger: Logger, + max_cached_workflows: Integer, + max_concurrent_workflow_task_polls: Integer, + nonsticky_to_sticky_poll_ratio: Numeric, + max_concurrent_activity_task_polls: Integer, + no_remote_activities: T::Boolean, + sticky_queue_schedule_to_start_timeout: Numeric, + max_heartbeat_throttle_interval: Numeric, + default_heartbeat_throttle_interval: Numeric, + max_activities_per_second: T.nilable(Numeric), + max_task_queue_activities_per_second: T.nilable(Numeric), + graceful_shutdown_period: Numeric, + disable_eager_activity_execution: T::Boolean, + illegal_workflow_calls: T::Hash[String, T.any(Symbol, T::Array[T.any(Symbol, Temporalio::Worker::IllegalWorkflowCallValidator)], Temporalio::Worker::IllegalWorkflowCallValidator)], + workflow_failure_exception_types: T::Array[T.class_of(Exception)], + workflow_payload_codec_thread_pool: T.nilable(Temporalio::Worker::ThreadPool), + unsafe_workflow_io_enabled: T::Boolean, + deployment_options: Temporalio::Worker::DeploymentOptions, + workflow_task_poller_behavior: Temporalio::Worker::PollerBehavior, + activity_task_poller_behavior: Temporalio::Worker::PollerBehavior, + debug_mode: T::Boolean + ).void + end + def initialize( + client:, + task_queue:, + activities: T.unsafe(nil), + workflows: T.unsafe(nil), + tuner: T.unsafe(nil), + activity_executors: T.unsafe(nil), + workflow_executor: T.unsafe(nil), + plugins: T.unsafe(nil), + interceptors: T.unsafe(nil), + identity: T.unsafe(nil), + logger: T.unsafe(nil), + max_cached_workflows: T.unsafe(nil), + max_concurrent_workflow_task_polls: T.unsafe(nil), + nonsticky_to_sticky_poll_ratio: T.unsafe(nil), + max_concurrent_activity_task_polls: T.unsafe(nil), + no_remote_activities: T.unsafe(nil), + sticky_queue_schedule_to_start_timeout: T.unsafe(nil), + max_heartbeat_throttle_interval: T.unsafe(nil), + default_heartbeat_throttle_interval: T.unsafe(nil), + max_activities_per_second: T.unsafe(nil), + max_task_queue_activities_per_second: T.unsafe(nil), + graceful_shutdown_period: T.unsafe(nil), + disable_eager_activity_execution: T.unsafe(nil), + illegal_workflow_calls: T.unsafe(nil), + workflow_failure_exception_types: T.unsafe(nil), + workflow_payload_codec_thread_pool: T.unsafe(nil), + unsafe_workflow_io_enabled: T.unsafe(nil), + deployment_options: T.unsafe(nil), + workflow_task_poller_behavior: T.unsafe(nil), + activity_task_poller_behavior: T.unsafe(nil), + debug_mode: T.unsafe(nil) + ); end + + sig { returns(String) } + def task_queue; end + + sig { returns(Temporalio::Client) } + def client; end + + sig { params(new_client: Temporalio::Client).void } + def client=(new_client); end + + sig do + type_parameters(:T) + .params( + cancellation: Temporalio::Cancellation, + shutdown_signals: T::Array[T.any(String, Integer)], + raise_in_block_on_shutdown: T.nilable(Exception), + wait_block_complete: T::Boolean, + block: T.nilable(T.proc.returns(T.type_parameter(:T))) + ).returns(T.type_parameter(:T)) + end + def run( + cancellation: T.unsafe(nil), + shutdown_signals: T.unsafe(nil), + raise_in_block_on_shutdown: T.unsafe(nil), + wait_block_complete: T.unsafe(nil), + &block + ); end + + class << self + extend T::Sig + + sig { returns(String) } + def default_build_id; end + + sig { returns(Temporalio::Worker::DeploymentOptions) } + def default_deployment_options; end + + sig do + type_parameters(:T) + .params( + workers: Temporalio::Worker, + cancellation: Temporalio::Cancellation, + shutdown_signals: T::Array[T.any(String, Integer)], + raise_in_block_on_shutdown: T.nilable(Exception), + wait_block_complete: T::Boolean, + block: T.nilable(T.proc.returns(T.type_parameter(:T))) + ).returns(T.type_parameter(:T)) + end + def run_all( + *workers, + cancellation: T.unsafe(nil), + shutdown_signals: T.unsafe(nil), + raise_in_block_on_shutdown: T.unsafe(nil), + wait_block_complete: T.unsafe(nil), + &block + ); end + + sig { returns(T::Hash[String, T.any(Symbol, T::Array[T.any(Symbol, IllegalWorkflowCallValidator)], IllegalWorkflowCallValidator)]) } + def default_illegal_workflow_calls; end + end +end + +class Temporalio::Worker::Options < ::Data + extend T::Sig + + sig { returns(Temporalio::Client) } + def client; end + + sig { returns(String) } + def task_queue; end + + sig { returns(T::Array[T.any(Temporalio::Activity::Definition, T.class_of(Temporalio::Activity::Definition), Temporalio::Activity::Definition::Info)]) } + def activities; end + + sig { returns(T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)]) } + def workflows; end + + sig { returns(Temporalio::Worker::Tuner) } + def tuner; end + + sig { returns(T::Hash[Symbol, Temporalio::Worker::ActivityExecutor]) } + def activity_executors; end + + sig { returns(Temporalio::Worker::WorkflowExecutor) } + def workflow_executor; end + + sig { returns(T::Array[Temporalio::Worker::Plugin]) } + def plugins; end + + sig { returns(T::Array[T.any(Temporalio::Worker::Interceptor::Activity, Temporalio::Worker::Interceptor::Workflow)]) } + def interceptors; end + + sig { returns(T.nilable(String)) } + def identity; end + + sig { returns(Logger) } + def logger; end + + sig { returns(Integer) } + def max_cached_workflows; end + + sig { returns(Integer) } + def max_concurrent_workflow_task_polls; end + + sig { returns(Numeric) } + def nonsticky_to_sticky_poll_ratio; end + + sig { returns(Integer) } + def max_concurrent_activity_task_polls; end + + sig { returns(T::Boolean) } + def no_remote_activities; end + + sig { returns(Numeric) } + def sticky_queue_schedule_to_start_timeout; end + + sig { returns(Numeric) } + def max_heartbeat_throttle_interval; end + + sig { returns(Numeric) } + def default_heartbeat_throttle_interval; end + + sig { returns(T.nilable(Numeric)) } + def max_activities_per_second; end + + sig { returns(T.nilable(Numeric)) } + def max_task_queue_activities_per_second; end + + sig { returns(Numeric) } + def graceful_shutdown_period; end + + sig { returns(T::Boolean) } + def disable_eager_activity_execution; end + + sig { returns(T::Hash[String, T.any(Symbol, T::Array[T.any(Symbol, Temporalio::Worker::IllegalWorkflowCallValidator)], Temporalio::Worker::IllegalWorkflowCallValidator)]) } + def illegal_workflow_calls; end + + sig { returns(T::Array[T.class_of(Exception)]) } + def workflow_failure_exception_types; end + + sig { returns(T.nilable(Temporalio::Worker::ThreadPool)) } + def workflow_payload_codec_thread_pool; end + + sig { returns(T::Boolean) } + def unsafe_workflow_io_enabled; end + + sig { returns(Temporalio::Worker::PollerBehavior) } + def workflow_task_poller_behavior; end + + sig { returns(Temporalio::Worker::PollerBehavior) } + def activity_task_poller_behavior; end + + sig { returns(Temporalio::Worker::DeploymentOptions) } + def deployment_options; end + + sig { returns(T::Boolean) } + def debug_mode; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Worker::Options) } + def with(**kwargs); end +end diff --git a/temporalio/rbi/temporalio/worker/activity_executor.rbi b/temporalio/rbi/temporalio/worker/activity_executor.rbi new file mode 100644 index 00000000..233e18b9 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/activity_executor.rbi @@ -0,0 +1,23 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::ActivityExecutor + extend T::Sig + + sig { returns(T::Hash[Symbol, Temporalio::Worker::ActivityExecutor]) } + def self.defaults; end + + sig { params(defn: Temporalio::Activity::Definition::Info).void } + def initialize_activity(defn); end + + sig { params(defn: Temporalio::Activity::Definition::Info, block: T.proc.void).void } + def execute_activity(defn, &block); end + + sig { returns(T.nilable(Temporalio::Activity::Context)) } + def activity_context; end + + sig { params(defn: Temporalio::Activity::Definition::Info, context: T.nilable(Temporalio::Activity::Context)).void } + def set_activity_context(defn, context); end +end diff --git a/temporalio/rbi/temporalio/worker/activity_executor/fiber.rbi b/temporalio/rbi/temporalio/worker/activity_executor/fiber.rbi new file mode 100644 index 00000000..d99400e7 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/activity_executor/fiber.rbi @@ -0,0 +1,23 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::ActivityExecutor::Fiber < Temporalio::Worker::ActivityExecutor + extend T::Sig + + sig { returns(Temporalio::Worker::ActivityExecutor::Fiber) } + def self.default; end + + sig { params(defn: Temporalio::Activity::Definition::Info).void } + def initialize_activity(defn); end + + sig { params(defn: Temporalio::Activity::Definition::Info, block: T.proc.void).void } + def execute_activity(defn, &block); end + + sig { returns(T.nilable(Temporalio::Activity::Context)) } + def activity_context; end + + sig { params(defn: Temporalio::Activity::Definition::Info, context: T.nilable(Temporalio::Activity::Context)).void } + def set_activity_context(defn, context); end +end diff --git a/temporalio/rbi/temporalio/worker/activity_executor/thread_pool.rbi b/temporalio/rbi/temporalio/worker/activity_executor/thread_pool.rbi new file mode 100644 index 00000000..85d219a2 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/activity_executor/thread_pool.rbi @@ -0,0 +1,23 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::ActivityExecutor::ThreadPool < ::Temporalio::Worker::ActivityExecutor + extend T::Sig + + sig { returns(Temporalio::Worker::ActivityExecutor::ThreadPool) } + def self.default; end + + sig { params(thread_pool: Temporalio::Worker::ThreadPool).void } + def initialize(thread_pool = T.unsafe(nil)); end + + sig { params(defn: Temporalio::Activity::Definition::Info, block: T.proc.void).void } + def execute_activity(defn, &block); end + + sig { returns(T.nilable(Temporalio::Activity::Context)) } + def activity_context; end + + sig { params(defn: Temporalio::Activity::Definition::Info, context: T.nilable(Temporalio::Activity::Context)).void } + def set_activity_context(defn, context); end +end diff --git a/temporalio/rbi/temporalio/worker/deployment_options.rbi b/temporalio/rbi/temporalio/worker/deployment_options.rbi new file mode 100644 index 00000000..59d5bfa8 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/deployment_options.rbi @@ -0,0 +1,26 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::DeploymentOptions < ::Data + extend T::Sig + + sig { returns(Temporalio::WorkerDeploymentVersion) } + def version; end + + sig { returns(T::Boolean) } + def use_worker_versioning; end + + sig { returns(Integer) } + def default_versioning_behavior; end + + sig do + params( + version: Temporalio::WorkerDeploymentVersion, + use_worker_versioning: T::Boolean, + default_versioning_behavior: Integer + ).void + end + def initialize(version:, use_worker_versioning: T.unsafe(nil), default_versioning_behavior: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/worker/illegal_workflow_call_validator.rbi b/temporalio/rbi/temporalio/worker/illegal_workflow_call_validator.rbi new file mode 100644 index 00000000..48b60ca7 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/illegal_workflow_call_validator.rbi @@ -0,0 +1,36 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::IllegalWorkflowCallValidator + extend T::Sig + + sig { returns(T.nilable(Symbol)) } + attr_reader :method_name + + sig { returns(T.proc.params(arg0: Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo).void) } + attr_reader :block + + sig { params(method_name: T.nilable(Symbol), block: T.proc.params(arg0: Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo).void).void } + def initialize(method_name: T.unsafe(nil), &block); end + + sig { returns(T::Array[Temporalio::Worker::IllegalWorkflowCallValidator]) } + def self.default_time_validators; end + + sig { returns(Temporalio::Worker::IllegalWorkflowCallValidator) } + def self.known_safe_mutex_validator; end +end + +class Temporalio::Worker::IllegalWorkflowCallValidator::CallInfo < ::Data + extend T::Sig + + sig { returns(String) } + def class_name; end + + sig { returns(Symbol) } + def method_name; end + + sig { returns(TracePoint) } + def trace_point; end +end diff --git a/temporalio/rbi/temporalio/worker/interceptor.rbi b/temporalio/rbi/temporalio/worker/interceptor.rbi new file mode 100644 index 00000000..c49eeb0f --- /dev/null +++ b/temporalio/rbi/temporalio/worker/interceptor.rbi @@ -0,0 +1,492 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Worker::Interceptor; end + +module Temporalio::Worker::Interceptor::Activity + extend T::Sig + + sig { params(next_interceptor: Temporalio::Worker::Interceptor::Activity::Inbound).returns(Temporalio::Worker::Interceptor::Activity::Inbound) } + def intercept_activity(next_interceptor); end +end + +class Temporalio::Worker::Interceptor::Activity::ExecuteInput < ::Data + extend T::Sig + + sig { returns(Proc) } + def proc; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Activity::HeartbeatInput < ::Data + extend T::Sig + + sig { returns(T::Array[T.nilable(Object)]) } + def details; end + + sig { returns(T.nilable(T::Array[Object])) } + def detail_hints; end +end + +class Temporalio::Worker::Interceptor::Activity::Inbound + extend T::Sig + + sig { returns(Temporalio::Worker::Interceptor::Activity::Inbound) } + attr_reader :next_interceptor + + sig { params(next_interceptor: Temporalio::Worker::Interceptor::Activity::Inbound).void } + def initialize(next_interceptor); end + + sig { params(outbound: Temporalio::Worker::Interceptor::Activity::Outbound).returns(Temporalio::Worker::Interceptor::Activity::Outbound) } + def init(outbound); end + + sig { params(input: Temporalio::Worker::Interceptor::Activity::ExecuteInput).returns(T.nilable(Object)) } + def execute(input); end +end + +class Temporalio::Worker::Interceptor::Activity::Outbound + extend T::Sig + + sig { returns(Temporalio::Worker::Interceptor::Activity::Outbound) } + attr_reader :next_interceptor + + sig { params(next_interceptor: Temporalio::Worker::Interceptor::Activity::Outbound).void } + def initialize(next_interceptor); end + + sig { params(input: Temporalio::Worker::Interceptor::Activity::HeartbeatInput).void } + def heartbeat(input); end +end + +module Temporalio::Worker::Interceptor::Workflow + extend T::Sig + + sig { params(next_interceptor: Temporalio::Worker::Interceptor::Workflow::Inbound).returns(Temporalio::Worker::Interceptor::Workflow::Inbound) } + def intercept_workflow(next_interceptor); end +end + +class Temporalio::Worker::Interceptor::Workflow::ExecuteInput < ::Data + extend T::Sig + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::HandleSignalInput < ::Data + extend T::Sig + + sig { returns(String) } + def signal; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(Temporalio::Workflow::Definition::Signal) } + def definition; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::HandleQueryInput < ::Data + extend T::Sig + + sig { returns(String) } + def id; end + + sig { returns(String) } + def query; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(Temporalio::Workflow::Definition::Query) } + def definition; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::HandleUpdateInput < ::Data + extend T::Sig + + sig { returns(String) } + def id; end + + sig { returns(String) } + def update; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(Temporalio::Workflow::Definition::Update) } + def definition; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::Inbound + extend T::Sig + + sig { returns(Temporalio::Worker::Interceptor::Workflow::Inbound) } + attr_reader :next_interceptor + + sig { params(next_interceptor: Temporalio::Worker::Interceptor::Workflow::Inbound).void } + def initialize(next_interceptor); end + + sig { params(outbound: Temporalio::Worker::Interceptor::Workflow::Outbound).returns(Temporalio::Worker::Interceptor::Workflow::Outbound) } + def init(outbound); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::ExecuteInput).returns(T.nilable(Object)) } + def execute(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::HandleSignalInput).void } + def handle_signal(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::HandleQueryInput).returns(T.nilable(Object)) } + def handle_query(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::HandleUpdateInput).void } + def validate_update(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::HandleUpdateInput).returns(T.nilable(Object)) } + def handle_update(input); end +end + +class Temporalio::Worker::Interceptor::Workflow::CancelExternalWorkflowInput < ::Data + extend T::Sig + + sig { returns(String) } + def id; end + + sig { returns(T.nilable(String)) } + def run_id; end +end + +class Temporalio::Worker::Interceptor::Workflow::ExecuteActivityInput < ::Data + extend T::Sig + + sig { returns(String) } + def activity; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(String) } + def task_queue; end + + sig { returns(T.nilable(String)) } + def summary; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def schedule_to_close_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def schedule_to_start_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def start_to_close_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def heartbeat_timeout; end + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + def retry_policy; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T.nilable(Integer)) } + def cancellation_type; end + + sig { returns(T.nilable(String)) } + def activity_id; end + + sig { returns(T::Boolean) } + def disable_eager_execution; end + + sig { returns(Temporalio::Priority) } + def priority; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::ExecuteLocalActivityInput < ::Data + extend T::Sig + + sig { returns(String) } + def activity; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(T.nilable(String)) } + def summary; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def schedule_to_close_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def schedule_to_start_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def start_to_close_timeout; end + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + def retry_policy; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def local_retry_threshold; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T.nilable(Integer)) } + def cancellation_type; end + + sig { returns(T.nilable(String)) } + def activity_id; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::InitializeContinueAsNewErrorInput < ::Data + extend T::Sig + + sig { returns(Temporalio::Workflow::ContinueAsNewError) } + def error; end +end + +class Temporalio::Worker::Interceptor::Workflow::SignalChildWorkflowInput < ::Data + extend T::Sig + + sig { returns(String) } + def id; end + + sig { returns(String) } + def signal; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::SignalExternalWorkflowInput < ::Data + extend T::Sig + + sig { returns(String) } + def id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig { returns(String) } + def signal; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::SleepInput < ::Data + extend T::Sig + + sig { returns(T.nilable(T.any(Integer, Float))) } + def duration; end + + sig { returns(T.nilable(String)) } + def summary; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end +end + +class Temporalio::Worker::Interceptor::Workflow::StartChildWorkflowInput < ::Data + extend T::Sig + + sig { returns(String) } + def workflow; end + + sig { returns(T::Array[T.nilable(Object)]) } + def args; end + + sig { returns(String) } + def id; end + + sig { returns(String) } + def task_queue; end + + sig { returns(T.nilable(String)) } + def static_summary; end + + sig { returns(T.nilable(String)) } + def static_details; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T.nilable(Integer)) } + def cancellation_type; end + + sig { returns(Integer) } + def parent_close_policy; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def execution_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def run_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def task_timeout; end + + sig { returns(Integer) } + def id_reuse_policy; end + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + def retry_policy; end + + sig { returns(T.nilable(String)) } + def cron_schedule; end + + sig { returns(T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)])) } + def memo; end + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + def search_attributes; end + + sig { returns(Temporalio::Priority) } + def priority; end + + sig { returns(T.nilable(T::Array[Object])) } + def arg_hints; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::StartNexusOperationInput < ::Data + extend T::Sig + + sig { returns(String) } + def endpoint; end + + sig { returns(String) } + def service; end + + sig { returns(String) } + def operation; end + + sig { returns(T.nilable(Object)) } + def arg; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def schedule_to_close_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def schedule_to_start_timeout; end + + sig { returns(T.nilable(T.any(Integer, Float))) } + def start_to_close_timeout; end + + sig { returns(T.nilable(Integer)) } + def cancellation_type; end + + sig { returns(T.nilable(String)) } + def summary; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T.nilable(Object)) } + def arg_hint; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { returns(T::Hash[String, String]) } + def headers; end +end + +class Temporalio::Worker::Interceptor::Workflow::Outbound + extend T::Sig + + sig { returns(Temporalio::Worker::Interceptor::Workflow::Outbound) } + attr_reader :next_interceptor + + sig { params(next_interceptor: Temporalio::Worker::Interceptor::Workflow::Outbound).void } + def initialize(next_interceptor); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::CancelExternalWorkflowInput).void } + def cancel_external_workflow(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::ExecuteActivityInput).returns(T.nilable(Object)) } + def execute_activity(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::ExecuteLocalActivityInput).returns(T.nilable(Object)) } + def execute_local_activity(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::InitializeContinueAsNewErrorInput).void } + def initialize_continue_as_new_error(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::SignalChildWorkflowInput).void } + def signal_child_workflow(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::SignalExternalWorkflowInput).void } + def signal_external_workflow(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::SleepInput).void } + def sleep(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::StartChildWorkflowInput).returns(Temporalio::Workflow::ChildWorkflowHandle) } + def start_child_workflow(input); end + + sig { params(input: Temporalio::Worker::Interceptor::Workflow::StartNexusOperationInput).returns(Temporalio::Workflow::NexusOperationHandle) } + def start_nexus_operation(input); end +end diff --git a/temporalio/rbi/temporalio/worker/plugin.rbi b/temporalio/rbi/temporalio/worker/plugin.rbi new file mode 100644 index 00000000..d929e66f --- /dev/null +++ b/temporalio/rbi/temporalio/worker/plugin.rbi @@ -0,0 +1,52 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Worker::Plugin + extend T::Sig + + sig { returns(String) } + def name; end + + sig { params(options: Temporalio::Worker::Options).returns(Temporalio::Worker::Options) } + def configure_worker(options); end + + sig { params(options: Temporalio::Worker::Plugin::RunWorkerOptions, next_call: T.proc.params(arg0: Temporalio::Worker::Plugin::RunWorkerOptions).returns(T.anything)).returns(T.anything) } + def run_worker(options, next_call); end + + sig { params(options: Temporalio::Worker::WorkflowReplayer::Options).returns(Temporalio::Worker::WorkflowReplayer::Options) } + def configure_workflow_replayer(options); end + + sig { params(options: Temporalio::Worker::Plugin::WithWorkflowReplayWorkerOptions, next_call: T.proc.params(arg0: Temporalio::Worker::Plugin::WithWorkflowReplayWorkerOptions).returns(T.anything)).returns(T.anything) } + def with_workflow_replay_worker(options, next_call); end +end + +class Temporalio::Worker::Plugin::RunWorkerOptions < ::Data + extend T::Sig + + sig { returns(Temporalio::Worker) } + def worker; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T::Array[T.any(String, Integer)]) } + def shutdown_signals; end + + sig { returns(T.nilable(Exception)) } + def raise_in_block_on_shutdown; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Worker::Plugin::RunWorkerOptions) } + def with(**kwargs); end +end + +class Temporalio::Worker::Plugin::WithWorkflowReplayWorkerOptions < ::Data + extend T::Sig + + sig { returns(Temporalio::Worker::WorkflowReplayer::ReplayWorker) } + def worker; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Worker::Plugin::WithWorkflowReplayWorkerOptions) } + def with(**kwargs); end +end diff --git a/temporalio/rbi/temporalio/worker/poller_behavior.rbi b/temporalio/rbi/temporalio/worker/poller_behavior.rbi new file mode 100644 index 00000000..42d63030 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/poller_behavior.rbi @@ -0,0 +1,32 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::PollerBehavior; end + +class Temporalio::Worker::PollerBehavior::SimpleMaximum < ::Temporalio::Worker::PollerBehavior + extend T::Sig + + sig { returns(Integer) } + attr_reader :maximum + + sig { params(maximum: Integer).void } + def initialize(maximum); end +end + +class Temporalio::Worker::PollerBehavior::Autoscaling < ::Temporalio::Worker::PollerBehavior + extend T::Sig + + sig { returns(Integer) } + attr_reader :minimum + + sig { returns(Integer) } + attr_reader :maximum + + sig { returns(Integer) } + attr_reader :initial + + sig { params(minimum: Integer, maximum: Integer, initial: Integer).void } + def initialize(minimum: T.unsafe(nil), maximum: T.unsafe(nil), initial: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/worker/thread_pool.rbi b/temporalio/rbi/temporalio/worker/thread_pool.rbi new file mode 100644 index 00000000..33638139 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/thread_pool.rbi @@ -0,0 +1,41 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::ThreadPool + extend T::Sig + + sig { returns(Temporalio::Worker::ThreadPool) } + def self.default; end + + sig { params(max_threads: T.nilable(Integer), idle_timeout: Float).void } + def initialize(max_threads: T.unsafe(nil), idle_timeout: T.unsafe(nil)); end + + sig { params(block: T.proc.void).void } + def execute(&block); end + + sig { returns(Integer) } + def largest_length; end + + sig { returns(Integer) } + def scheduled_task_count; end + + sig { returns(Integer) } + def completed_task_count; end + + sig { returns(Integer) } + def active_count; end + + sig { returns(Integer) } + def length; end + + sig { returns(Integer) } + def queue_length; end + + sig { void } + def shutdown; end + + sig { void } + def kill; end +end diff --git a/temporalio/rbi/temporalio/worker/tuner.rbi b/temporalio/rbi/temporalio/worker/tuner.rbi new file mode 100644 index 00000000..a1a4486c --- /dev/null +++ b/temporalio/rbi/temporalio/worker/tuner.rbi @@ -0,0 +1,224 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::Tuner + extend T::Sig + + sig { returns(SlotSupplier) } + attr_reader :workflow_slot_supplier + + sig { returns(SlotSupplier) } + attr_reader :activity_slot_supplier + + sig { returns(SlotSupplier) } + attr_reader :local_activity_slot_supplier + + sig { returns(T.nilable(Temporalio::Worker::ThreadPool)) } + attr_reader :custom_slot_supplier_thread_pool + + sig do + params( + workflow_slot_supplier: SlotSupplier, + activity_slot_supplier: SlotSupplier, + local_activity_slot_supplier: SlotSupplier, + custom_slot_supplier_thread_pool: T.nilable(Temporalio::Worker::ThreadPool) + ).void + end + def initialize( + workflow_slot_supplier:, + activity_slot_supplier:, + local_activity_slot_supplier:, + custom_slot_supplier_thread_pool: T.unsafe(nil) + ); end + + class << self + extend T::Sig + + sig do + params( + workflow_slots: Integer, + activity_slots: Integer, + local_activity_slots: Integer + ).returns(Temporalio::Worker::Tuner) + end + def create_fixed(workflow_slots: T.unsafe(nil), activity_slots: T.unsafe(nil), local_activity_slots: T.unsafe(nil)); end + + sig do + params( + target_memory_usage: Float, + target_cpu_usage: Float, + workflow_options: ResourceBasedSlotOptions, + activity_options: ResourceBasedSlotOptions, + local_activity_options: ResourceBasedSlotOptions + ).returns(Temporalio::Worker::Tuner) + end + def create_resource_based( + target_memory_usage:, + target_cpu_usage:, + workflow_options: T.unsafe(nil), + activity_options: T.unsafe(nil), + local_activity_options: T.unsafe(nil) + ); end + end +end + +class Temporalio::Worker::Tuner::SlotSupplier; end + +class Temporalio::Worker::Tuner::SlotSupplier::Fixed < ::Temporalio::Worker::Tuner::SlotSupplier + extend T::Sig + + sig { returns(Integer) } + attr_reader :slots + + sig { params(slots: Integer).void } + def initialize(slots); end +end + +class Temporalio::Worker::Tuner::SlotSupplier::ResourceBased < ::Temporalio::Worker::Tuner::SlotSupplier + extend T::Sig + + sig { returns(Temporalio::Worker::Tuner::ResourceBasedTunerOptions) } + attr_reader :tuner_options + + sig { returns(Temporalio::Worker::Tuner::ResourceBasedSlotOptions) } + attr_reader :slot_options + + sig do + params( + tuner_options: Temporalio::Worker::Tuner::ResourceBasedTunerOptions, + slot_options: Temporalio::Worker::Tuner::ResourceBasedSlotOptions + ).void + end + def initialize(tuner_options:, slot_options:); end +end + +class Temporalio::Worker::Tuner::SlotSupplier::Custom < ::Temporalio::Worker::Tuner::SlotSupplier + extend T::Sig + + sig do + params( + context: ReserveContext, + cancellation: Temporalio::Cancellation, + block: T.proc.params(arg0: Object).void + ).void + end + def reserve_slot(context, cancellation, &block); end + + sig { params(context: ReserveContext).returns(Object) } + def try_reserve_slot(context); end + + sig { params(context: MarkUsedContext).void } + def mark_slot_used(context); end + + sig { params(context: ReleaseContext).void } + def release_slot(context); end +end + +class Temporalio::Worker::Tuner::SlotSupplier::Custom::ReserveContext < ::Data + extend T::Sig + + sig { returns(Symbol) } + def slot_type; end + + sig { returns(String) } + def task_queue; end + + sig { returns(String) } + def worker_identity; end + + sig { returns(String) } + def worker_deployment_name; end + + sig { returns(String) } + def worker_build_id; end + + sig { returns(T::Boolean) } + def sticky?; end +end + +class Temporalio::Worker::Tuner::SlotSupplier::Custom::MarkUsedContext < ::Data + extend T::Sig + + sig { returns(T.any(Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Workflow, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Activity, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::LocalActivity, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Nexus)) } + def slot_info; end + + sig { returns(Object) } + def permit; end +end + +class Temporalio::Worker::Tuner::SlotSupplier::Custom::ReleaseContext < ::Data + extend T::Sig + + sig { returns(T.nilable(T.any(Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Workflow, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Activity, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::LocalActivity, Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Nexus))) } + def slot_info; end + + sig { returns(Object) } + def permit; end +end + +module Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo; end + +class Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Workflow < ::Data + extend T::Sig + + sig { returns(String) } + def workflow_type; end + + sig { returns(T::Boolean) } + def sticky?; end +end + +class Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Activity < ::Data + extend T::Sig + + sig { returns(String) } + def activity_type; end +end + +class Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::LocalActivity < ::Data + extend T::Sig + + sig { returns(String) } + def activity_type; end +end + +class Temporalio::Worker::Tuner::SlotSupplier::Custom::SlotInfo::Nexus < ::Data + extend T::Sig + + sig { returns(String) } + def service; end + + sig { returns(String) } + def operation; end +end + +class Temporalio::Worker::Tuner::ResourceBasedTunerOptions < ::Data + extend T::Sig + + sig { returns(Float) } + def target_memory_usage; end + + sig { returns(Float) } + def target_cpu_usage; end + + sig { params(target_memory_usage: Float, target_cpu_usage: Float).void } + def initialize(target_memory_usage:, target_cpu_usage:); end +end + +class Temporalio::Worker::Tuner::ResourceBasedSlotOptions < ::Data + extend T::Sig + + sig { returns(T.nilable(Integer)) } + def min_slots; end + + sig { returns(T.nilable(Integer)) } + def max_slots; end + + sig { returns(T.nilable(Numeric)) } + def ramp_throttle; end + + sig { params(min_slots: T.nilable(Integer), max_slots: T.nilable(Integer), ramp_throttle: T.nilable(Float)).void } + def initialize(min_slots:, max_slots:, ramp_throttle:); end +end diff --git a/temporalio/rbi/temporalio/worker/workflow_executor.rbi b/temporalio/rbi/temporalio/worker/workflow_executor.rbi new file mode 100644 index 00000000..2d7aae75 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/workflow_executor.rbi @@ -0,0 +1,11 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::WorkflowExecutor + extend T::Sig + + sig { void } + def initialize; end +end diff --git a/temporalio/rbi/temporalio/worker/workflow_executor/thread_pool.rbi b/temporalio/rbi/temporalio/worker/workflow_executor/thread_pool.rbi new file mode 100644 index 00000000..b2c4abdf --- /dev/null +++ b/temporalio/rbi/temporalio/worker/workflow_executor/thread_pool.rbi @@ -0,0 +1,16 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::WorkflowExecutor::ThreadPool < ::Temporalio::Worker::WorkflowExecutor + extend T::Sig + + sig { returns(Temporalio::Worker::WorkflowExecutor::ThreadPool) } + def self.default; end + + sig { params(max_threads: Integer, thread_pool: Temporalio::Worker::ThreadPool).void } + def initialize(max_threads: T.unsafe(nil), thread_pool: T.unsafe(nil)); end +end + +class Temporalio::Worker::WorkflowExecutor::ThreadPool::DeadlockError < ::Exception; end diff --git a/temporalio/rbi/temporalio/worker/workflow_replayer.rbi b/temporalio/rbi/temporalio/worker/workflow_replayer.rbi new file mode 100644 index 00000000..a3c00dc7 --- /dev/null +++ b/temporalio/rbi/temporalio/worker/workflow_replayer.rbi @@ -0,0 +1,150 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Worker::WorkflowReplayer + extend T::Sig + + sig { returns(Temporalio::Worker::WorkflowReplayer::Options) } + attr_reader :options + + sig do + params( + workflows: T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)], + namespace: String, + task_queue: String, + data_converter: Temporalio::Converters::DataConverter, + workflow_executor: Temporalio::Worker::WorkflowExecutor, + plugins: T::Array[Temporalio::Worker::Plugin], + interceptors: T::Array[Temporalio::Worker::Interceptor::Workflow], + identity: T.nilable(String), + logger: Logger, + illegal_workflow_calls: T::Hash[String, T.any(Symbol, T::Array[Symbol])], + workflow_failure_exception_types: T::Array[T.class_of(Exception)], + workflow_payload_codec_thread_pool: T.nilable(Temporalio::Worker::ThreadPool), + unsafe_workflow_io_enabled: T::Boolean, + debug_mode: T::Boolean, + runtime: Temporalio::Runtime, + block: T.nilable(T.proc.params(worker: Temporalio::Worker::WorkflowReplayer::ReplayWorker).returns(T.anything)) + ).void + end + def initialize( + workflows:, + namespace: T.unsafe(nil), + task_queue: T.unsafe(nil), + data_converter: T.unsafe(nil), + workflow_executor: T.unsafe(nil), + plugins: T.unsafe(nil), + interceptors: T.unsafe(nil), + identity: T.unsafe(nil), + logger: T.unsafe(nil), + illegal_workflow_calls: T.unsafe(nil), + workflow_failure_exception_types: T.unsafe(nil), + workflow_payload_codec_thread_pool: T.unsafe(nil), + unsafe_workflow_io_enabled: T.unsafe(nil), + debug_mode: T.unsafe(nil), + runtime: T.unsafe(nil), + &block + ); end + + sig do + params( + history: Temporalio::WorkflowHistory, + raise_on_replay_failure: T::Boolean + ).returns(Temporalio::Worker::WorkflowReplayer::ReplayResult) + end + def replay_workflow(history, raise_on_replay_failure: T.unsafe(nil)); end + + sig do + params( + histories: T::Enumerable[Temporalio::WorkflowHistory], + raise_on_replay_failure: T::Boolean + ).returns(T::Array[Temporalio::Worker::WorkflowReplayer::ReplayResult]) + end + def replay_workflows(histories, raise_on_replay_failure: T.unsafe(nil)); end + + sig do + type_parameters(:T) + .params(block: T.proc.params(worker: Temporalio::Worker::WorkflowReplayer::ReplayWorker).returns(T.type_parameter(:T))) + .returns(T.type_parameter(:T)) + end + def with_replay_worker(&block); end +end + +class Temporalio::Worker::WorkflowReplayer::Options < ::Data + extend T::Sig + + sig { returns(T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)]) } + def workflows; end + + sig { returns(String) } + def namespace; end + + sig { returns(String) } + def task_queue; end + + sig { returns(Temporalio::Converters::DataConverter) } + def data_converter; end + + sig { returns(Temporalio::Worker::WorkflowExecutor) } + def workflow_executor; end + + sig { returns(T::Array[Temporalio::Worker::Plugin]) } + def plugins; end + + sig { returns(T::Array[Temporalio::Worker::Interceptor::Workflow]) } + def interceptors; end + + sig { returns(T.nilable(String)) } + def identity; end + + sig { returns(Logger) } + def logger; end + + sig { returns(T::Hash[String, T.any(Symbol, T::Array[Symbol])]) } + def illegal_workflow_calls; end + + sig { returns(T::Array[T.class_of(Exception)]) } + def workflow_failure_exception_types; end + + sig { returns(T.nilable(Temporalio::Worker::ThreadPool)) } + def workflow_payload_codec_thread_pool; end + + sig { returns(T::Boolean) } + def unsafe_workflow_io_enabled; end + + sig { returns(T::Boolean) } + def debug_mode; end + + sig { returns(Temporalio::Runtime) } + def runtime; end + + sig { params(kwargs: T.untyped).returns(Temporalio::Worker::WorkflowReplayer::Options) } + def with(**kwargs); end +end + +class Temporalio::Worker::WorkflowReplayer::ReplayResult + extend T::Sig + + sig { returns(Temporalio::WorkflowHistory) } + attr_reader :history + + sig { returns(T.nilable(Exception)) } + attr_reader :replay_failure + + sig { params(history: Temporalio::WorkflowHistory, replay_failure: T.nilable(Exception)).void } + def initialize(history:, replay_failure:); end +end + +class Temporalio::Worker::WorkflowReplayer::ReplayWorker + extend T::Sig + + sig do + params( + history: Temporalio::WorkflowHistory, + raise_on_replay_failure: T::Boolean + ).returns(Temporalio::Worker::WorkflowReplayer::ReplayResult) + end + def replay_workflow(history, raise_on_replay_failure: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/worker_deployment_version.rbi b/temporalio/rbi/temporalio/worker_deployment_version.rbi new file mode 100644 index 00000000..a380ca66 --- /dev/null +++ b/temporalio/rbi/temporalio/worker_deployment_version.rbi @@ -0,0 +1,32 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::WorkerDeploymentVersion < ::Data + sig { params(deployment_name: String, build_id: String).void } + def initialize(deployment_name:, build_id:); end + + sig { params(canonical: String).returns(Temporalio::WorkerDeploymentVersion) } + def self.from_canonical_string(canonical); end + + sig { returns(String) } + def deployment_name; end + + sig { returns(String) } + def build_id; end + + sig { returns(String) } + def to_canonical_string; end + + class << self + sig { params(args: T.untyped).returns(Temporalio::WorkerDeploymentVersion) } + def [](*args); end + + sig { returns(T::Array[Symbol]) } + def members; end + + sig { params(args: T.untyped).returns(Temporalio::WorkerDeploymentVersion) } + def new(*args); end + end +end diff --git a/temporalio/rbi/temporalio/workflow.rbi b/temporalio/rbi/temporalio/workflow.rbi new file mode 100644 index 00000000..b67c0d03 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow.rbi @@ -0,0 +1,391 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Workflow + class << self + extend T::Sig + + sig { returns(T::Boolean) } + def all_handlers_finished?; end + + sig { returns(Temporalio::Cancellation) } + def cancellation; end + + sig { returns(T::Boolean) } + def continue_as_new_suggested; end + + sig { params(endpoint: T.any(Symbol, String), service: T.any(Symbol, String)).returns(Temporalio::Workflow::NexusClient) } + def create_nexus_client(endpoint:, service:); end + + sig { returns(T::Array[Integer]) } + def suggest_continue_as_new_reasons; end + + sig { returns(T::Boolean) } + def target_worker_deployment_version_changed?; end + + sig { returns(String) } + def current_details; end + + sig { params(details: T.nilable(String)).void } + def current_details=(details); end + + sig { returns(Integer) } + def current_history_length; end + + sig { returns(T.nilable(Temporalio::WorkerDeploymentVersion)) } + def current_deployment_version; end + + sig { returns(Integer) } + def current_history_size; end + + sig { returns(T.nilable(Temporalio::Workflow::UpdateInfo)) } + def current_update_info; end + + sig { params(patch_id: T.any(Symbol, String)).void } + def deprecate_patch(patch_id); end + + sig do + params( + activity: T.any(T.class_of(Temporalio::Activity::Definition), Symbol, String), + args: T.nilable(Object), + task_queue: String, + summary: T.nilable(String), + schedule_to_close_timeout: T.nilable(T.any(Integer, Float)), + schedule_to_start_timeout: T.nilable(T.any(Integer, Float)), + start_to_close_timeout: T.nilable(T.any(Integer, Float)), + heartbeat_timeout: T.nilable(T.any(Integer, Float)), + retry_policy: T.nilable(Temporalio::RetryPolicy), + cancellation: Temporalio::Cancellation, + cancellation_type: Integer, + activity_id: T.nilable(String), + disable_eager_execution: T::Boolean, + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).returns(T.nilable(Object)) + end + def execute_activity( + activity, + *args, + task_queue: T.unsafe(nil), + summary: T.unsafe(nil), + schedule_to_close_timeout: T.unsafe(nil), + schedule_to_start_timeout: T.unsafe(nil), + start_to_close_timeout: T.unsafe(nil), + heartbeat_timeout: T.unsafe(nil), + retry_policy: T.unsafe(nil), + cancellation: T.unsafe(nil), + cancellation_type: T.unsafe(nil), + activity_id: T.unsafe(nil), + disable_eager_execution: T.unsafe(nil), + priority: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end + + sig do + params( + workflow: T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, String), + args: T.nilable(Object), + id: String, + task_queue: String, + static_summary: T.nilable(String), + static_details: T.nilable(String), + cancellation: Temporalio::Cancellation, + cancellation_type: Integer, + parent_close_policy: Integer, + execution_timeout: T.nilable(T.any(Integer, Float)), + run_timeout: T.nilable(T.any(Integer, Float)), + task_timeout: T.nilable(T.any(Integer, Float)), + id_reuse_policy: Integer, + retry_policy: T.nilable(Temporalio::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).returns(T.nilable(Object)) + end + def execute_child_workflow( + workflow, + *args, + id: T.unsafe(nil), + task_queue: T.unsafe(nil), + static_summary: T.unsafe(nil), + static_details: T.unsafe(nil), + cancellation: T.unsafe(nil), + cancellation_type: T.unsafe(nil), + parent_close_policy: T.unsafe(nil), + execution_timeout: T.unsafe(nil), + run_timeout: T.unsafe(nil), + task_timeout: T.unsafe(nil), + id_reuse_policy: T.unsafe(nil), + retry_policy: T.unsafe(nil), + cron_schedule: T.unsafe(nil), + memo: T.unsafe(nil), + search_attributes: T.unsafe(nil), + priority: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end + + sig do + params( + activity: T.any(T.class_of(Temporalio::Activity::Definition), Symbol, String), + args: T.nilable(Object), + summary: T.nilable(String), + schedule_to_close_timeout: T.nilable(T.any(Integer, Float)), + schedule_to_start_timeout: T.nilable(T.any(Integer, Float)), + start_to_close_timeout: T.nilable(T.any(Integer, Float)), + retry_policy: T.nilable(Temporalio::RetryPolicy), + local_retry_threshold: T.nilable(T.any(Integer, Float)), + cancellation: Temporalio::Cancellation, + cancellation_type: Integer, + activity_id: T.nilable(String), + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).returns(T.nilable(Object)) + end + def execute_local_activity( + activity, + *args, + summary: T.unsafe(nil), + schedule_to_close_timeout: T.unsafe(nil), + schedule_to_start_timeout: T.unsafe(nil), + start_to_close_timeout: T.unsafe(nil), + retry_policy: T.unsafe(nil), + local_retry_threshold: T.unsafe(nil), + cancellation: T.unsafe(nil), + cancellation_type: T.unsafe(nil), + activity_id: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end + + sig { params(workflow_id: String, run_id: T.nilable(String)).returns(Temporalio::Workflow::ExternalWorkflowHandle) } + def external_workflow_handle(workflow_id, run_id: T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def in_workflow?; end + + sig { returns(Temporalio::Workflow::Info) } + def info; end + + sig { returns(T.nilable(Temporalio::Workflow::Definition)) } + def instance; end + + sig { returns(Temporalio::ScopedLogger) } + def logger; end + + sig { returns(T::Hash[String, T.nilable(Object)]) } + def memo; end + + sig { returns(Temporalio::Metric::Meter) } + def metric_meter; end + + sig { returns(Time) } + def now; end + + sig { params(patch_id: T.any(Symbol, String)).returns(T::Boolean) } + def patched(patch_id); end + + sig { returns(Temporalio::Converters::PayloadConverter) } + def payload_converter; end + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Query]) } + def query_handlers; end + + sig { returns(Random) } + def random; end + + sig { returns(Temporalio::SearchAttributes) } + def search_attributes; end + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Signal]) } + def signal_handlers; end + + sig { params(duration: T.nilable(T.any(Integer, Float)), summary: T.nilable(String), cancellation: Temporalio::Cancellation).void } + def sleep(duration, summary: T.unsafe(nil), cancellation: T.unsafe(nil)); end + + sig do + params( + workflow: T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info, Symbol, String), + args: T.nilable(Object), + id: String, + task_queue: String, + static_summary: T.nilable(String), + static_details: T.nilable(String), + cancellation: Temporalio::Cancellation, + cancellation_type: Integer, + parent_close_policy: Integer, + execution_timeout: T.nilable(T.any(Integer, Float)), + run_timeout: T.nilable(T.any(Integer, Float)), + task_timeout: T.nilable(T.any(Integer, Float)), + id_reuse_policy: Integer, + retry_policy: T.nilable(Temporalio::RetryPolicy), + cron_schedule: T.nilable(String), + memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + priority: Temporalio::Priority, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).returns(Temporalio::Workflow::ChildWorkflowHandle) + end + def start_child_workflow( + workflow, + *args, + id: T.unsafe(nil), + task_queue: T.unsafe(nil), + static_summary: T.unsafe(nil), + static_details: T.unsafe(nil), + cancellation: T.unsafe(nil), + cancellation_type: T.unsafe(nil), + parent_close_policy: T.unsafe(nil), + execution_timeout: T.unsafe(nil), + run_timeout: T.unsafe(nil), + task_timeout: T.unsafe(nil), + id_reuse_policy: T.unsafe(nil), + retry_policy: T.unsafe(nil), + cron_schedule: T.unsafe(nil), + memo: T.unsafe(nil), + search_attributes: T.unsafe(nil), + priority: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end + + sig { returns(T::Hash[Object, Object]) } + def storage; end + + sig do + type_parameters(:T) + .params( + duration: T.nilable(T.any(Integer, Float)), + exception_class: T.class_of(Exception), + message: String, + summary: T.nilable(String), + block: T.proc.returns(T.type_parameter(:T)) + ).returns(T.type_parameter(:T)) + end + def timeout(duration, exception_class = T.unsafe(nil), message = T.unsafe(nil), summary: T.unsafe(nil), &block); end + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Update]) } + def update_handlers; end + + sig { params(hash: T::Hash[T.any(Symbol, String), T.nilable(Object)]).void } + def upsert_memo(hash); end + + sig { params(updates: Temporalio::SearchAttributes::Update).void } + def upsert_search_attributes(*updates); end + + sig do + type_parameters(:T) + .params( + cancellation: T.nilable(Temporalio::Cancellation), + block: T.proc.returns(T.type_parameter(:T)) + ).returns(T.type_parameter(:T)) + end + def wait_condition(cancellation: T.unsafe(nil), &block); end + end +end + +module Temporalio::Workflow::Unsafe + class << self + extend T::Sig + + sig { returns(T::Boolean) } + def replaying?; end + + sig { returns(T::Boolean) } + def replaying_history_events?; end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def illegal_call_tracing_disabled(&block); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def io_enabled(&block); end + + sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } + def durable_scheduler_disabled(&block); end + end +end + +class Temporalio::Workflow::ContinueAsNewError < ::Temporalio::Error + extend T::Sig + + sig do + params( + args: T.nilable(Object), + workflow: T.nilable(T.any(T.class_of(Temporalio::Workflow::Definition), String, Symbol)), + task_queue: T.nilable(String), + run_timeout: T.nilable(T.any(Integer, Float)), + task_timeout: T.nilable(T.any(Integer, Float)), + retry_policy: T.nilable(Temporalio::RetryPolicy), + memo: T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)]), + search_attributes: T.nilable(Temporalio::SearchAttributes), + arg_hints: T.nilable(T::Array[Object]), + headers: T::Hash[String, T.nilable(Object)], + initial_versioning_behavior: T.nilable(Integer) + ).void + end + def initialize( + *args, + workflow: T.unsafe(nil), + task_queue: T.unsafe(nil), + run_timeout: T.unsafe(nil), + task_timeout: T.unsafe(nil), + retry_policy: T.unsafe(nil), + memo: T.unsafe(nil), + search_attributes: T.unsafe(nil), + arg_hints: T.unsafe(nil), + headers: T.unsafe(nil), + initial_versioning_behavior: T.unsafe(nil) + ); end + + sig { returns(T::Array[T.nilable(Object)]) } + attr_accessor :args + + sig { returns(T.nilable(T.any(T.class_of(Temporalio::Workflow::Definition), String, Symbol))) } + attr_accessor :workflow + + sig { returns(T.nilable(String)) } + attr_accessor :task_queue + + sig { returns(T.nilable(T.any(Integer, Float))) } + attr_accessor :run_timeout + + sig { returns(T.nilable(T.any(Integer, Float))) } + attr_accessor :task_timeout + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + attr_accessor :retry_policy + + sig { returns(T.nilable(T::Hash[T.any(String, Symbol), T.nilable(Object)])) } + attr_accessor :memo + + sig { returns(T.nilable(Temporalio::SearchAttributes)) } + attr_accessor :search_attributes + + sig { returns(T.nilable(T::Array[Object])) } + attr_accessor :arg_hints + + sig { returns(T::Hash[String, T.nilable(Object)]) } + attr_accessor :headers + + sig { returns(T.nilable(Integer)) } + attr_accessor :initial_versioning_behavior + +end + +class Temporalio::Workflow::InvalidWorkflowStateError < ::Temporalio::Error; end + +class Temporalio::Workflow::NondeterminismError < ::Temporalio::Error; end + +class Temporalio::Workflow::Mutex < ::Mutex; end + +class Temporalio::Workflow::Queue < ::Queue; end + +class Temporalio::Workflow::SizedQueue < ::SizedQueue; end diff --git a/temporalio/rbi/temporalio/workflow/activity_cancellation_type.rbi b/temporalio/rbi/temporalio/workflow/activity_cancellation_type.rbi new file mode 100644 index 00000000..440a867f --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/activity_cancellation_type.rbi @@ -0,0 +1,10 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Workflow::ActivityCancellationType + TRY_CANCEL = T.let(T.unsafe(nil), Integer) + WAIT_CANCELLATION_COMPLETED = T.let(T.unsafe(nil), Integer) + ABANDON = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/workflow/child_workflow_cancellation_type.rbi b/temporalio/rbi/temporalio/workflow/child_workflow_cancellation_type.rbi new file mode 100644 index 00000000..72399782 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/child_workflow_cancellation_type.rbi @@ -0,0 +1,11 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Workflow::ChildWorkflowCancellationType + ABANDON = T.let(T.unsafe(nil), Integer) + TRY_CANCEL = T.let(T.unsafe(nil), Integer) + WAIT_CANCELLATION_COMPLETED = T.let(T.unsafe(nil), Integer) + WAIT_CANCELLATION_REQUESTED = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/workflow/child_workflow_handle.rbi b/temporalio/rbi/temporalio/workflow/child_workflow_handle.rbi new file mode 100644 index 00000000..c1b7dbbb --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/child_workflow_handle.rbi @@ -0,0 +1,30 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Workflow::ChildWorkflowHandle + extend T::Sig + + sig { returns(String) } + def id; end + + sig { returns(String) } + def first_execution_run_id; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { params(result_hint: T.nilable(Object)).returns(T.nilable(Object)) } + def result(result_hint: T.unsafe(nil)); end + + sig do + params( + signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String), + args: T.nilable(Object), + cancellation: Temporalio::Cancellation, + arg_hints: T.nilable(T::Array[Object]) + ).void + end + def signal(signal, *args, cancellation: T.unsafe(nil), arg_hints: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/workflow/definition.rbi b/temporalio/rbi/temporalio/workflow/definition.rbi new file mode 100644 index 00000000..d3b67d3e --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/definition.rbi @@ -0,0 +1,308 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Workflow::Definition + extend T::Sig + + sig { params(args: T.nilable(Object)).returns(T.nilable(Object)) } + def execute(*args); end + + class << self + extend T::Sig + + sig { params(workflow_name: T.any(String, Symbol)).void } + def workflow_name(workflow_name); end + + sig { params(value: T::Boolean).void } + def workflow_dynamic(value = T.unsafe(nil)); end + + sig { params(value: T::Boolean).void } + def workflow_raw_args(value = T.unsafe(nil)); end + + sig { params(hints: Object).void } + def workflow_arg_hint(*hints); end + + sig { params(hint: Object).void } + def workflow_result_hint(hint); end + + sig { params(types: T.class_of(Exception)).void } + def workflow_failure_exception_type(*types); end + + sig { params(attr_names: Symbol, description: T.nilable(String)).void } + def workflow_query_attr_reader(*attr_names, description: T.unsafe(nil)); end + + sig { params(behavior: Integer).void } + def workflow_versioning_behavior(behavior); end + + sig { params(value: T::Boolean).void } + def workflow_init(value = T.unsafe(nil)); end + + sig do + params( + name: T.nilable(T.any(String, Symbol)), + description: T.nilable(String), + dynamic: T::Boolean, + raw_args: T::Boolean, + unfinished_policy: Integer, + arg_hints: T.nilable(T.any(Object, T::Array[Object])) + ).void + end + def workflow_signal( + name: T.unsafe(nil), + description: T.unsafe(nil), + dynamic: T.unsafe(nil), + raw_args: T.unsafe(nil), + unfinished_policy: T.unsafe(nil), + arg_hints: T.unsafe(nil) + ); end + + sig do + params( + name: T.nilable(T.any(String, Symbol)), + description: T.nilable(String), + dynamic: T::Boolean, + raw_args: T::Boolean, + arg_hints: T.nilable(T.any(Object, T::Array[Object])), + result_hint: T.nilable(Object) + ).void + end + def workflow_query( + name: T.unsafe(nil), + description: T.unsafe(nil), + dynamic: T.unsafe(nil), + raw_args: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end + + sig do + params( + name: T.nilable(T.any(String, Symbol)), + description: T.nilable(String), + dynamic: T::Boolean, + raw_args: T::Boolean, + unfinished_policy: Integer, + arg_hints: T.nilable(T.any(Object, T::Array[Object])), + result_hint: T.nilable(Object) + ).void + end + def workflow_update( + name: T.unsafe(nil), + description: T.unsafe(nil), + dynamic: T.unsafe(nil), + raw_args: T.unsafe(nil), + unfinished_policy: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end + + sig { params(update_method: Symbol).void } + def workflow_update_validator(update_method); end + + sig { void } + def workflow_dynamic_options; end + end +end + +class Temporalio::Workflow::Definition::Info + extend T::Sig + + sig { returns(T.class_of(Temporalio::Workflow::Definition)) } + attr_reader :workflow_class + + sig { returns(T.nilable(String)) } + attr_reader :override_name + + sig { returns(T::Boolean) } + attr_reader :dynamic + + sig { returns(T::Boolean) } + attr_reader :init + + sig { returns(T::Boolean) } + attr_reader :raw_args + + sig { returns(T::Array[T.class_of(Exception)]) } + attr_reader :failure_exception_types + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Signal]) } + attr_reader :signals + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Query]) } + attr_reader :queries + + sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Update]) } + attr_reader :updates + + sig { returns(T.nilable(Integer)) } + attr_reader :versioning_behavior + + sig { returns(T.nilable(Symbol)) } + attr_reader :dynamic_options_method + + sig { returns(T.nilable(T::Array[Object])) } + attr_reader :arg_hints + + sig { returns(T.nilable(Object)) } + attr_reader :result_hint + + sig { params(workflow_class: T.class_of(Temporalio::Workflow::Definition)).returns(Temporalio::Workflow::Definition::Info) } + def self.from_class(workflow_class); end + + sig do + params( + workflow_class: T.class_of(Temporalio::Workflow::Definition), + override_name: T.nilable(String), + dynamic: T::Boolean, + init: T::Boolean, + raw_args: T::Boolean, + failure_exception_types: T::Array[T.class_of(Exception)], + signals: T::Hash[String, Temporalio::Workflow::Definition::Signal], + queries: T::Hash[String, Temporalio::Workflow::Definition::Query], + updates: T::Hash[String, Temporalio::Workflow::Definition::Update], + versioning_behavior: T.nilable(Integer), + dynamic_options_method: T.nilable(Symbol), + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).void + end + def initialize( + workflow_class:, + override_name: T.unsafe(nil), + dynamic: T.unsafe(nil), + init: T.unsafe(nil), + raw_args: T.unsafe(nil), + failure_exception_types: T.unsafe(nil), + signals: T.unsafe(nil), + queries: T.unsafe(nil), + updates: T.unsafe(nil), + versioning_behavior: T.unsafe(nil), + dynamic_options_method: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end + + sig { returns(T.nilable(String)) } + def name; end +end + +class Temporalio::Workflow::Definition::Signal + extend T::Sig + + sig { returns(T.nilable(String)) } + attr_reader :name + + sig { returns(T.any(Symbol, Proc)) } + attr_reader :to_invoke + + sig { returns(T.nilable(String)) } + attr_reader :description + + sig { returns(T::Boolean) } + attr_reader :raw_args + + sig { returns(Integer) } + attr_reader :unfinished_policy + + sig { returns(T.nilable(T::Array[Object])) } + attr_reader :arg_hints + + sig do + params( + name: T.nilable(String), + to_invoke: T.any(Symbol, Proc), + description: T.nilable(String), + raw_args: T::Boolean, + unfinished_policy: Integer, + arg_hints: T.nilable(T::Array[Object]) + ).void + end + def initialize(name:, to_invoke:, description: T.unsafe(nil), raw_args: T.unsafe(nil), unfinished_policy: T.unsafe(nil), arg_hints: T.unsafe(nil)); end +end + +class Temporalio::Workflow::Definition::Query + extend T::Sig + + sig { returns(T.nilable(String)) } + attr_reader :name + + sig { returns(T.any(Symbol, Proc)) } + attr_reader :to_invoke + + sig { returns(T.nilable(String)) } + attr_reader :description + + sig { returns(T::Boolean) } + attr_reader :raw_args + + sig { returns(T.nilable(T::Array[Object])) } + attr_reader :arg_hints + + sig { returns(T.nilable(Object)) } + attr_reader :result_hint + + sig do + params( + name: T.nilable(String), + to_invoke: T.any(Symbol, Proc), + description: T.nilable(String), + raw_args: T::Boolean, + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).void + end + def initialize(name:, to_invoke:, description: T.unsafe(nil), raw_args: T.unsafe(nil), arg_hints: T.unsafe(nil), result_hint: T.unsafe(nil)); end +end + +class Temporalio::Workflow::Definition::Update + extend T::Sig + + sig { returns(T.nilable(String)) } + attr_reader :name + + sig { returns(T.any(Symbol, Proc)) } + attr_reader :to_invoke + + sig { returns(T.nilable(String)) } + attr_reader :description + + sig { returns(T::Boolean) } + attr_reader :raw_args + + sig { returns(Integer) } + attr_reader :unfinished_policy + + sig { returns(T.nilable(T.any(Symbol, Proc))) } + attr_reader :validator_to_invoke + + sig { returns(T.nilable(T::Array[Object])) } + attr_reader :arg_hints + + sig { returns(T.nilable(Object)) } + attr_reader :result_hint + + sig do + params( + name: T.nilable(String), + to_invoke: T.any(Symbol, Proc), + description: T.nilable(String), + raw_args: T::Boolean, + unfinished_policy: Integer, + validator_to_invoke: T.nilable(T.any(Symbol, Proc)), + arg_hints: T.nilable(T::Array[Object]), + result_hint: T.nilable(Object) + ).void + end + def initialize( + name:, + to_invoke:, + description: T.unsafe(nil), + raw_args: T.unsafe(nil), + unfinished_policy: T.unsafe(nil), + validator_to_invoke: T.unsafe(nil), + arg_hints: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end +end diff --git a/temporalio/rbi/temporalio/workflow/external_workflow_handle.rbi b/temporalio/rbi/temporalio/workflow/external_workflow_handle.rbi new file mode 100644 index 00000000..503e8595 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/external_workflow_handle.rbi @@ -0,0 +1,27 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Workflow::ExternalWorkflowHandle + extend T::Sig + + sig { returns(String) } + def id; end + + sig { returns(T.nilable(String)) } + def run_id; end + + sig do + params( + signal: T.any(Temporalio::Workflow::Definition::Signal, Symbol, String), + args: T.nilable(Object), + cancellation: Temporalio::Cancellation, + arg_hints: T.nilable(T::Array[Object]) + ).void + end + def signal(signal, *args, cancellation: T.unsafe(nil), arg_hints: T.unsafe(nil)); end + + sig { void } + def cancel; end +end diff --git a/temporalio/rbi/temporalio/workflow/future.rbi b/temporalio/rbi/temporalio/workflow/future.rbi new file mode 100644 index 00000000..1258bf85 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/future.rbi @@ -0,0 +1,65 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Workflow::Future + extend T::Sig + extend T::Generic + + Elem = type_member + + sig { returns(T.nilable(Elem)) } + attr_reader :result + + sig { returns(T.nilable(Exception)) } + attr_reader :failure + + sig { params(block: T.nilable(T.proc.returns(Elem))).void } + def initialize(&); end + + sig { returns(T::Boolean) } + def done?; end + + sig { returns(T::Boolean) } + def result?; end + + sig { params(result: Elem).void } + def result=(result); end + + sig { returns(T::Boolean) } + def failure?; end + + sig { params(failure: Exception).void } + def failure=(failure); end + + sig { returns(Elem) } + def wait; end + + sig { returns(T.nilable(Elem)) } + def wait_no_raise; end + + class << self + extend T::Sig + + sig { params(futures: Temporalio::Workflow::Future[T.anything]).returns(Temporalio::Workflow::Future[NilClass]) } + def all_of(*futures); end + + sig do + type_parameters(:T) + .params(futures: Temporalio::Workflow::Future[T.type_parameter(:T)]) + .returns(Temporalio::Workflow::Future[T.type_parameter(:T)]) + end + def any_of(*futures); end + + sig do + type_parameters(:T) + .params(futures: Temporalio::Workflow::Future[T.type_parameter(:T)]) + .returns(Temporalio::Workflow::Future[Temporalio::Workflow::Future[T.type_parameter(:T)]]) + end + def try_any_of(*futures); end + + sig { params(futures: Temporalio::Workflow::Future[T.anything]).returns(Temporalio::Workflow::Future[NilClass]) } + def try_all_of(*futures); end + end +end diff --git a/temporalio/rbi/temporalio/workflow/handler_unfinished_policy.rbi b/temporalio/rbi/temporalio/workflow/handler_unfinished_policy.rbi new file mode 100644 index 00000000..448a66a5 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/handler_unfinished_policy.rbi @@ -0,0 +1,9 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Workflow::HandlerUnfinishedPolicy + WARN_AND_ABANDON = T.let(T.unsafe(nil), Integer) + ABANDON = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/workflow/info.rbi b/temporalio/rbi/temporalio/workflow/info.rbi new file mode 100644 index 00000000..4b90dd28 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/info.rbi @@ -0,0 +1,103 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Workflow::Info < ::Struct + extend T::Sig + + sig { returns(Integer) } + def attempt; end + + sig { returns(T.nilable(String)) } + def continued_run_id; end + + sig { returns(T.nilable(String)) } + def cron_schedule; end + + sig { returns(T.nilable(Numeric)) } + def execution_timeout; end + + sig { returns(String) } + def first_execution_run_id; end + + sig { returns(T::Hash[String, Temporalio::Api::Common::V1::Payload]) } + def headers; end + + sig { returns(T.nilable(Exception)) } + def last_failure; end + + sig { returns(T.nilable(Object)) } + def last_result; end + + sig { returns(T::Boolean) } + def has_last_result?; end + + sig { returns(String) } + def namespace; end + + sig { returns(T.nilable(Temporalio::Workflow::Info::ParentInfo)) } + def parent; end + + sig { returns(Temporalio::Priority) } + def priority; end + + sig { returns(T.nilable(Temporalio::RetryPolicy)) } + def retry_policy; end + + sig { returns(T.nilable(Temporalio::Workflow::Info::RootInfo)) } + def root; end + + sig { returns(String) } + def run_id; end + + sig { returns(T.nilable(Numeric)) } + def run_timeout; end + + sig { returns(Time) } + def start_time; end + + sig { returns(String) } + def task_queue; end + + sig { returns(Float) } + def task_timeout; end + + sig { returns(String) } + def workflow_id; end + + sig { returns(String) } + def workflow_type; end + + sig { returns(T::Hash[Symbol, Object]) } + def to_h; end +end + +class Temporalio::Workflow::Info::ParentInfo < ::Struct + extend T::Sig + + sig { returns(String) } + def namespace; end + + sig { returns(String) } + def run_id; end + + sig { returns(String) } + def workflow_id; end + + sig { returns(T::Hash[Symbol, String]) } + def to_h; end +end + +class Temporalio::Workflow::Info::RootInfo < ::Struct + extend T::Sig + + sig { returns(String) } + def run_id; end + + sig { returns(String) } + def workflow_id; end + + sig { returns(T::Hash[Symbol, String]) } + def to_h; end +end diff --git a/temporalio/rbi/temporalio/workflow/nexus_client.rbi b/temporalio/rbi/temporalio/workflow/nexus_client.rbi new file mode 100644 index 00000000..7982aaba --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/nexus_client.rbi @@ -0,0 +1,68 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Workflow::NexusClient + extend T::Sig + + sig { returns(String) } + def endpoint; end + + sig { returns(String) } + def service; end + + sig do + params( + operation: T.any(Symbol, String), + arg: T.nilable(Object), + schedule_to_close_timeout: T.nilable(T.any(Integer, Float)), + schedule_to_start_timeout: T.nilable(T.any(Integer, Float)), + start_to_close_timeout: T.nilable(T.any(Integer, Float)), + cancellation_type: Integer, + summary: T.nilable(String), + cancellation: Temporalio::Cancellation, + arg_hint: T.nilable(Object), + result_hint: T.nilable(Object) + ).returns(Temporalio::Workflow::NexusOperationHandle) + end + def start_operation( + operation, + arg, + schedule_to_close_timeout: T.unsafe(nil), + schedule_to_start_timeout: T.unsafe(nil), + start_to_close_timeout: T.unsafe(nil), + cancellation_type: T.unsafe(nil), + summary: T.unsafe(nil), + cancellation: T.unsafe(nil), + arg_hint: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end + + sig do + params( + operation: T.any(Symbol, String), + arg: T.nilable(Object), + schedule_to_close_timeout: T.nilable(T.any(Integer, Float)), + schedule_to_start_timeout: T.nilable(T.any(Integer, Float)), + start_to_close_timeout: T.nilable(T.any(Integer, Float)), + cancellation_type: Integer, + summary: T.nilable(String), + cancellation: Temporalio::Cancellation, + arg_hint: T.nilable(Object), + result_hint: T.nilable(Object) + ).returns(T.nilable(Object)) + end + def execute_operation( + operation, + arg, + schedule_to_close_timeout: T.unsafe(nil), + schedule_to_start_timeout: T.unsafe(nil), + start_to_close_timeout: T.unsafe(nil), + cancellation_type: T.unsafe(nil), + summary: T.unsafe(nil), + cancellation: T.unsafe(nil), + arg_hint: T.unsafe(nil), + result_hint: T.unsafe(nil) + ); end +end diff --git a/temporalio/rbi/temporalio/workflow/nexus_operation_cancellation_type.rbi b/temporalio/rbi/temporalio/workflow/nexus_operation_cancellation_type.rbi new file mode 100644 index 00000000..ba80a22a --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/nexus_operation_cancellation_type.rbi @@ -0,0 +1,11 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Workflow::NexusOperationCancellationType + WAIT_CANCELLATION_COMPLETED = T.let(T.unsafe(nil), Integer) + ABANDON = T.let(T.unsafe(nil), Integer) + TRY_CANCEL = T.let(T.unsafe(nil), Integer) + WAIT_CANCELLATION_REQUESTED = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/workflow/nexus_operation_handle.rbi b/temporalio/rbi/temporalio/workflow/nexus_operation_handle.rbi new file mode 100644 index 00000000..1caeff96 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/nexus_operation_handle.rbi @@ -0,0 +1,17 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Workflow::NexusOperationHandle + extend T::Sig + + sig { returns(T.nilable(String)) } + def operation_token; end + + sig { returns(T.nilable(Object)) } + def result_hint; end + + sig { params(result_hint: T.nilable(Object)).returns(T.nilable(Object)) } + def result(result_hint: T.unsafe(nil)); end +end diff --git a/temporalio/rbi/temporalio/workflow/parent_close_policy.rbi b/temporalio/rbi/temporalio/workflow/parent_close_policy.rbi new file mode 100644 index 00000000..a5826131 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/parent_close_policy.rbi @@ -0,0 +1,11 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +module Temporalio::Workflow::ParentClosePolicy + UNSPECIFIED = T.let(T.unsafe(nil), Integer) + TERMINATE = T.let(T.unsafe(nil), Integer) + ABANDON = T.let(T.unsafe(nil), Integer) + REQUEST_CANCEL = T.let(T.unsafe(nil), Integer) +end diff --git a/temporalio/rbi/temporalio/workflow/update_info.rbi b/temporalio/rbi/temporalio/workflow/update_info.rbi new file mode 100644 index 00000000..e70878cb --- /dev/null +++ b/temporalio/rbi/temporalio/workflow/update_info.rbi @@ -0,0 +1,17 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::Workflow::UpdateInfo < ::Struct + extend T::Sig + + sig { returns(String) } + def id; end + + sig { returns(String) } + def name; end + + sig { returns(T::Hash[Symbol, String]) } + def to_h; end +end diff --git a/temporalio/rbi/temporalio/workflow_history.rbi b/temporalio/rbi/temporalio/workflow_history.rbi new file mode 100644 index 00000000..0ebef452 --- /dev/null +++ b/temporalio/rbi/temporalio/workflow_history.rbi @@ -0,0 +1,24 @@ +# typed: true + +# Sorbet RBI types for the Temporal Ruby SDK. +# This file was split from rbi/temporalio.rbi by extra/split_rbi.rb. + +class Temporalio::WorkflowHistory + sig { params(events: T::Array[Temporalio::Api::History::V1::HistoryEvent]).void } + def initialize(events); end + + sig { params(json: String).returns(Temporalio::WorkflowHistory) } + def self.from_history_json(json); end + + sig { returns(T::Array[Temporalio::Api::History::V1::HistoryEvent]) } + attr_reader :events + + sig { returns(String) } + def workflow_id; end + + sig { returns(String) } + def to_history_json; end + + sig { params(other: Temporalio::WorkflowHistory).returns(T::Boolean) } + def ==(other); end +end diff --git a/temporalio/sig/temporalio/api/cloud/cloudservice.rbs b/temporalio/sig/temporalio/api/cloud/cloudservice.rbs new file mode 100644 index 00000000..dc9b888f --- /dev/null +++ b/temporalio/sig/temporalio/api/cloud/cloudservice.rbs @@ -0,0 +1,8 @@ +module Temporalio + module Api + module Cloud + module CloudService + end + end + end +end diff --git a/temporalio/sig/temporalio/api/operatorservice.rbs b/temporalio/sig/temporalio/api/operatorservice.rbs new file mode 100644 index 00000000..12e9a59d --- /dev/null +++ b/temporalio/sig/temporalio/api/operatorservice.rbs @@ -0,0 +1,6 @@ +module Temporalio + module Api + module OperatorService + end + end +end diff --git a/temporalio/sig/temporalio/api/workflowservice.rbs b/temporalio/sig/temporalio/api/workflowservice.rbs new file mode 100644 index 00000000..fa90fb7e --- /dev/null +++ b/temporalio/sig/temporalio/api/workflowservice.rbs @@ -0,0 +1,6 @@ +module Temporalio + module Api + module WorkflowService + end + end +end diff --git a/temporalio/sig/temporalio/client/connection.rbs b/temporalio/sig/temporalio/client/connection.rbs index 083b8c1f..1e2ed35f 100644 --- a/temporalio/sig/temporalio/client/connection.rbs +++ b/temporalio/sig/temporalio/client/connection.rbs @@ -97,13 +97,9 @@ module Temporalio attr_reader options: Options - # TODO(cretz): Update when generated - # attr_reader workflow_service: WorkflowService - # attr_reader operator_service: OperatorService - # attr_reader cloud_service: CloudService - attr_reader workflow_service: untyped - attr_reader operator_service: untyped - attr_reader cloud_service: untyped + attr_reader workflow_service: WorkflowService + attr_reader operator_service: OperatorService + attr_reader cloud_service: CloudService def initialize: ( target_host: String, @@ -131,4 +127,4 @@ module Temporalio private def new_core_client: -> Internal::Bridge::Client end end -end \ No newline at end of file +end diff --git a/temporalio/sig/temporalio/client/workflow_handle.rbs b/temporalio/sig/temporalio/client/workflow_handle.rbs index e95ffaa5..b625e77e 100644 --- a/temporalio/sig/temporalio/client/workflow_handle.rbs +++ b/temporalio/sig/temporalio/client/workflow_handle.rbs @@ -28,6 +28,7 @@ module Temporalio def fetch_history: ( ?event_filter_type: Integer, + ?skip_archival: bool, ?rpc_options: RPCOptions? ) -> WorkflowHistory diff --git a/temporalio/sig/temporalio/converters.rbs b/temporalio/sig/temporalio/converters.rbs new file mode 100644 index 00000000..2e29be31 --- /dev/null +++ b/temporalio/sig/temporalio/converters.rbs @@ -0,0 +1,4 @@ +module Temporalio + module Converters + end +end diff --git a/temporalio/sig/temporalio/env_config.rbs b/temporalio/sig/temporalio/env_config.rbs index 53290366..dbc3bfe1 100644 --- a/temporalio/sig/temporalio/env_config.rbs +++ b/temporalio/sig/temporalio/env_config.rbs @@ -21,7 +21,7 @@ module Temporalio ) -> void def to_h: -> Hash[Symbol, untyped] - def to_client_tls_options: -> (untyped | false) + def to_client_tls_options: -> (Client::Connection::TLSOptions | false) private @@ -34,7 +34,7 @@ module Temporalio attr_reader namespace: String? attr_reader api_key: String? attr_reader tls: ClientConfigTLS? - attr_reader grpc_meta: Hash[untyped, untyped] + attr_reader grpc_meta: Hash[String, String] def self.from_h: (Hash[untyped, untyped] hash) -> ClientConfigProfile @@ -52,7 +52,7 @@ module Temporalio ?namespace: String?, ?api_key: String?, ?tls: ClientConfigTLS?, - ?grpc_meta: Hash[untyped, untyped] + ?grpc_meta: Hash[String, String] ) -> void def to_h: -> Hash[Symbol, untyped] @@ -83,4 +83,4 @@ module Temporalio def to_h: -> Hash[String, Hash[Symbol, untyped]] end end -end \ No newline at end of file +end diff --git a/temporalio/sig/temporalio/internal.rbs b/temporalio/sig/temporalio/internal.rbs new file mode 100644 index 00000000..8e825e9d --- /dev/null +++ b/temporalio/sig/temporalio/internal.rbs @@ -0,0 +1,4 @@ +module Temporalio + module Internal + end +end diff --git a/temporalio/sig/temporalio/internal/bridge/api.rbs b/temporalio/sig/temporalio/internal/bridge/api.rbs new file mode 100644 index 00000000..8d423010 --- /dev/null +++ b/temporalio/sig/temporalio/internal/bridge/api.rbs @@ -0,0 +1,8 @@ +module Temporalio + module Internal + module Bridge + module Api + end + end + end +end diff --git a/temporalio/sig/temporalio/internal/bridge/client.rbs b/temporalio/sig/temporalio/internal/bridge/client.rbs index 7bf929d2..8d5cd36d 100644 --- a/temporalio/sig/temporalio/internal/bridge/client.rbs +++ b/temporalio/sig/temporalio/internal/bridge/client.rbs @@ -121,7 +121,7 @@ module Temporalio class RPCFailure < Error def code: -> Temporalio::Error::RPCError::Code::enum def message: -> String - def details: -> String + def details: -> String? end class CancellationToken @@ -131,4 +131,4 @@ module Temporalio end end end -end \ No newline at end of file +end diff --git a/temporalio/sig/temporalio/testing/workflow_environment.rbs b/temporalio/sig/temporalio/testing/workflow_environment.rbs index 437dbfef..41a6a40b 100644 --- a/temporalio/sig/temporalio/testing/workflow_environment.rbs +++ b/temporalio/sig/temporalio/testing/workflow_environment.rbs @@ -104,9 +104,9 @@ module Temporalio def current_time: -> Time - def create_nexus_endpoint: (name: String, task_queue: String) -> untyped + def create_nexus_endpoint: (name: String, task_queue: String) -> Api::Nexus::V1::Endpoint - def delete_nexus_endpoint: (untyped endpoint) -> nil + def delete_nexus_endpoint: (Api::Nexus::V1::Endpoint endpoint) -> nil def auto_time_skipping_disabled: [T] { -> T } -> T @@ -138,4 +138,4 @@ module Temporalio end end end -end \ No newline at end of file +end diff --git a/temporalio/sig/temporalio/workflow/info.rbs b/temporalio/sig/temporalio/workflow/info.rbs index e8fc4b72..5fa9bd80 100644 --- a/temporalio/sig/temporalio/workflow/info.rbs +++ b/temporalio/sig/temporalio/workflow/info.rbs @@ -60,7 +60,7 @@ module Temporalio workflow_id: String ) -> void - def to_h: -> Hash[Symbol, untyped] + def to_h: -> Hash[Symbol, String] end class RootInfo @@ -72,7 +72,7 @@ module Temporalio workflow_id: String ) -> void - def to_h: -> Hash[Symbol, untyped] + def to_h: -> Hash[Symbol, String] end end end diff --git a/temporalio/sig/temporalio/workflow/update_info.rbs b/temporalio/sig/temporalio/workflow/update_info.rbs index 7d98f83e..0846a4c6 100644 --- a/temporalio/sig/temporalio/workflow/update_info.rbs +++ b/temporalio/sig/temporalio/workflow/update_info.rbs @@ -9,7 +9,7 @@ module Temporalio name: String ) -> void - def to_h: -> Hash[Symbol, untyped] + def to_h: -> Hash[Symbol, String] end end end diff --git a/temporalio/temporalio.gemspec b/temporalio/temporalio.gemspec index cc89a725..8b13effb 100644 --- a/temporalio/temporalio.gemspec +++ b/temporalio/temporalio.gemspec @@ -15,7 +15,7 @@ Gem::Specification.new do |spec| spec.metadata['homepage_uri'] = spec.homepage spec.metadata['source_code_uri'] = 'https://github.com/temporalio/sdk-ruby' - spec.files = Dir['lib/**/*.rb', 'LICENSE', 'README.md', 'Cargo.*', + spec.files = Dir['lib/**/*.rb', 'sig/**/*.rbs', 'rbi/**/*.rbi', 'LICENSE', 'README.md', 'Cargo.*', 'temporalio.gemspec', 'Gemfile', 'Rakefile', '.yardopts'] spec.bindir = 'exe' diff --git a/temporalio/test/rbi_parse_test.rb b/temporalio/test/rbi_parse_test.rb new file mode 100644 index 00000000..cb140cbb --- /dev/null +++ b/temporalio/test/rbi_parse_test.rb @@ -0,0 +1,22 @@ +# frozen_string_literal: true + +require 'minitest/autorun' +require 'rbi' +require 'support/rbi_paths' + +class RbiParseTest < Minitest::Test + def test_all_rbi_files_parse + paths = RbiPaths.all + + assert paths.any?, 'Expected at least one RBI file' + + failures = paths.filter_map do |path| + RBI::Parser.parse_file(path) + nil + rescue StandardError => e + "#{path}: #{e.class}: #{e.message}" + end + + assert_empty failures, "RBI parse failures:\n#{failures.join("\n")}" + end +end diff --git a/temporalio/test/rbi_untyped_count_test.rb b/temporalio/test/rbi_untyped_count_test.rb new file mode 100644 index 00000000..69acc423 --- /dev/null +++ b/temporalio/test/rbi_untyped_count_test.rb @@ -0,0 +1,44 @@ +# frozen_string_literal: true + +require 'minitest/autorun' +require 'support/rbi_paths' + +class RbiUntypedCountTest < Minitest::Test + # Please do not increase this just to pass the test. Use concrete types where possible. + ANYTHING_COUNT = 22 + + # Data class initializers cannot be easily typed and are expected to use `T.untyped` + ALLOWED_UNTYPED_PATTERNS = [ + /sig \{ params\(args: T\.untyped\)\.returns\(/, + /sig \{ params\(kwargs: T\.untyped\)\.returns\(/ + ].freeze + + def test_untyped_usage_is_limited_to_data_constructor_shapes + unexpected = RbiPaths.manual.flat_map do |path| + File.readlines(path).each_with_index.filter_map do |line, index| + next unless line.include?('T.untyped') + next if ALLOWED_UNTYPED_PATTERNS.any? { |pattern| line.match?(pattern) } + + "#{path}:#{index + 1}: #{line.strip}" + end + end + + assert_empty unexpected, + "Manual RBI files should only use T.untyped for Data constructor/with shapes:\n" \ + "#{unexpected.join("\n")}" + end + + def test_anything_count_does_not_increase + actual_count = RbiPaths.manual.sum { |path| File.read(path).scan('T.anything').size } + ratchet_count = ANYTHING_COUNT + + assert actual_count <= ratchet_count, + "T.anything count increased from #{ratchet_count} to #{actual_count}. " \ + 'Use concrete types instead of T.anything where possible.' + + return unless actual_count < ratchet_count + + warn "T.anything count decreased from #{ratchet_count} to #{actual_count}. " \ + "Update ANYTHING_COUNT to #{actual_count} to ratchet down." + end +end diff --git a/temporalio/test/sig/support/rbi_paths.rbs b/temporalio/test/sig/support/rbi_paths.rbs new file mode 100644 index 00000000..10643985 --- /dev/null +++ b/temporalio/test/sig/support/rbi_paths.rbs @@ -0,0 +1,7 @@ +module RbiPaths + ROOT: String + GENERATED_PREFIXES: Array[String] + + def self.all: -> Array[String] + def self.manual: -> Array[String] +end diff --git a/temporalio/test/sig/support/sig_applicator.rbs b/temporalio/test/sig/support/sig_applicator.rbs new file mode 100644 index 00000000..c13d73dd --- /dev/null +++ b/temporalio/test/sig/support/sig_applicator.rbs @@ -0,0 +1,79 @@ +module SigApplicator + SKIP_CLASSES: Array[String] + SKIP_METHODS: Set[String] + ATTR_NODE_CLASSES: Array[Class] + + @type_errors: Array[String] + @summary_hook_registered: bool + + class MethodShape + attr_reader actual_params: Array[untyped] + attr_reader rbi_params: Array[untyped] + + def self.from: (UnboundMethod original, untyped method_node) -> MethodShape + + def initialize: (Array[untyped] actual_params, Array[untyped] rbi_params) -> void + + def actual_block_param: -> untyped? + def rbi_block_param: -> untyped? + def actual_block?: -> bool + def rbi_block?: -> bool + def actual_non_block_params: -> Array[untyped] + def sig_method_params: (untyped sig) -> Array[untyped] + end + + def self.apply_all!: -> void + def self.record_type_error: (String message) -> void + def self.type_errors: -> Array[String] + def self.suppress_errors: () { () -> untyped } -> untyped + + private + + def self.rbi_paths: -> Array[String] + def self.configure_error_handler!: -> void + def self.register_summary_hook!: -> void + def self.raise_recorded_type_errors!: -> void + def self.raise_instrumentation_errors!: (Array[String] errors) -> void + def self.apply_scope: (untyped node, Array[String] errors) -> [Integer, Integer] + def self.apply_method_sig: ( + Module target, + String class_name, + untyped method_node, + Array[String] errors, + ?class_method: bool, + ?sig_eval_scope: Module + ) -> (bool | :skipped) + def self.apply_attr_sig: ( + Module target, + String class_name, + untyped attr_node, + Array[String] errors, + ?class_method: bool, + ?sig_eval_scope: Module + ) -> [Integer, Integer] + def self.attr_method_sig_sources: (untyped attr_node, untyped attr_name) -> Array[[untyped, Array[String]]] + def self.writer_sig_sources: (untyped attr_node, untyped attr_name) -> Array[String] + def self.apply_sig_sources_to_method?: ( + Module target, + String full_name, + Symbol method_name, + Array[String] sig_sources, + Array[String] errors, + original: UnboundMethod, + singleton_method: bool, + sig_eval_scope: Module + ) -> bool + def self.anonymous_block?: (UnboundMethod method) -> bool? + def self.apply_sig_source: (Module sig_eval_scope, Module target, String sig_source, bool singleton_method) -> void + def self.apply_pending_sig: (Module sig_eval_scope, Module target, Symbol method_name, bool singleton_method) -> void + def self.define_local_method_copy: (Module target, Symbol method_name, UnboundMethod original) -> UnboundMethod + def self.method_visibility: (Module target, Symbol method_name) -> (:public | :protected | :private) + def self.restore_original_method: ( + Module target, + Symbol method_name, + UnboundMethod original, + ?remove_local_method: bool + ) -> void + def self.rewrite_block_param: (String sig_source, untyped method_node, untyped sig) -> String + def self.skip_method?: (UnboundMethod original, untyped method_node, Symbol method_name) -> bool +end diff --git a/temporalio/test/sig/support/sig_applicator_test.rbs b/temporalio/test/sig/support/sig_applicator_test.rbs new file mode 100644 index 00000000..fd674f2c --- /dev/null +++ b/temporalio/test/sig/support/sig_applicator_test.rbs @@ -0,0 +1,21 @@ +module Support + class SigApplicatorTest < Minitest::Test + @sig_applicator_type_errors: Array[String] + + private + + def parse_method: (String source) -> untyped + def skip_method?: (UnboundMethod original, untyped method_node, Symbol method_name) -> bool + def rewrite_block_param: (String sig_source, untyped method_node, untyped sig) -> String + def apply_method_sig: ( + Module target, + String class_name, + untyped method_node, + Array[String] errors, + sig_eval_scope: Module + ) -> (bool | :skipped) + def attr_method_sig_sources: (untyped attr_node, untyped attr_name) -> Array[[untyped, Array[String]]] + def replace_sig_applicator_type_errors: (Array[String] new_errors) -> Array[String] + def with_sig_applicator_rbi_paths: (Array[String] paths) { () -> untyped } -> untyped + end +end diff --git a/temporalio/test/sig/type_signature_coverage_test.rbs b/temporalio/test/sig/type_signature_coverage_test.rbs new file mode 100644 index 00000000..8d198eef --- /dev/null +++ b/temporalio/test/sig/type_signature_coverage_test.rbs @@ -0,0 +1,14 @@ +class TypeSignatureCoverageTest < Minitest::Test + ROOT: Pathname + LIB_ROOT: Pathname + RBI_ROOT: Pathname + SIG_ROOT: Pathname + + @ruby_paths: Array[String]? + + private + + def ruby_paths: -> Array[String] + def missing_signature_paths: (Pathname root, String extension) -> Array[String] + def relative_stems: (Pathname root, String pattern) -> Array[String] +end diff --git a/temporalio/test/support/rbi_paths.rb b/temporalio/test/support/rbi_paths.rb new file mode 100644 index 00000000..7c4da827 --- /dev/null +++ b/temporalio/test/support/rbi_paths.rb @@ -0,0 +1,30 @@ +# frozen_string_literal: true + +module RbiPaths + ROOT = File.expand_path('../../rbi', __dir__ || raise) + + GENERATED_PREFIXES = [ + File.join(ROOT, 'google', ''), + File.join(ROOT, 'temporalio', 'api', ''), + File.join(ROOT, 'temporalio', 'client', 'connection', ''), + File.join(ROOT, 'temporalio', 'internal', 'bridge', 'api', '') + ].freeze + + class << self + def all + Dir.glob(File.join(ROOT, '**', '*.rbi')) + end + + def manual + paths = [ + File.join(ROOT, 'temporalio.rbi'), + *Dir.glob(File.join(ROOT, 'temporalio', '**', '*.rbi')) + ] + paths + .uniq + .select { |path| File.file?(path) } + .reject { |path| GENERATED_PREFIXES.any? { |prefix| path.start_with?(prefix) } } + .sort + end + end +end diff --git a/temporalio/test/support/sig_applicator.rb b/temporalio/test/support/sig_applicator.rb new file mode 100644 index 00000000..cb2fe5c7 --- /dev/null +++ b/temporalio/test/support/sig_applicator.rb @@ -0,0 +1,476 @@ +# frozen_string_literal: true + +require 'rbi' +require 'sorbet-runtime' +require_relative 'rbi_paths' + +# Parses the SDK's manual RBI files and applies Sorbet runtime type signatures to the +# real (already-loaded) class implementations using Sorbet's method_added +# machinery. +# This enables sorbet-runtime to validate argument and return types at runtime +# during test execution, catching any drift between the RBI and actual code. +# +# Type mismatches are collected and reported as a summary after the test run +# rather than raising mid-execution. This avoids hanging workflows where a +# TypeError would cause an unrecoverable task failure that retries forever. +module SigApplicator + # Classes that use Sorbet generic type members which require the implementing class to include T::Generic. + SKIP_CLASSES = [ + 'Temporalio::Workflow::Future' + ].freeze + + # Specific class#method pairs to skip. + # Internal terminal interceptor implementations pass nil via super(nil) + # to these initializers, but the public API contract is non-nilable. + SKIP_METHODS = Set.new( + [ + 'Temporalio::Client::Interceptor::Outbound#initialize', + 'Temporalio::Worker::Interceptor::Activity::Inbound#initialize', + 'Temporalio::Worker::Interceptor::Activity::Outbound#initialize', + 'Temporalio::Worker::Interceptor::Workflow::Inbound#initialize', + 'Temporalio::Worker::Interceptor::Workflow::Outbound#initialize' + ] + ).freeze + + ATTR_NODE_CLASSES = [ + RBI::AttrAccessor, + RBI::AttrReader, + RBI::AttrWriter + ].freeze + + MethodShape = Data.define(:actual_params, :rbi_params) + + class MethodShape + def self.from(original, method_node) + new(original.parameters, method_node.params) + end + + def actual_block_param + actual_params.find { |kind, _| kind == :block } + end + + def rbi_block_param + rbi_params.find { |param| param.is_a?(RBI::BlockParam) } + end + + def actual_block? + !actual_block_param.nil? + end + + def rbi_block? + !rbi_block_param.nil? + end + + def actual_non_block_params + actual_params.reject { |param| param.first == :block } + end + + def sig_method_params(sig) + block_param_name = rbi_block_param&.name + return sig.params unless block_param_name + + sig.params.reject { |param| param.name.to_s == block_param_name.to_s } + end + end + + @type_errors = [] + @summary_hook_registered = false + + class << self + def apply_all! + @type_errors.clear + configure_error_handler! + register_summary_hook! + + # Make T::Sig available on all modules/classes so we don't need to + # extend it per-target inside apply_method_sig. + ::Module.include(::T::Sig) + + errors = [] + skipped = 0 + applied = 0 + + rbi_paths.each do |path| + tree = RBI::Parser.parse_file(path) + tree.nodes.each do |node| + a, s = apply_scope(node, errors) + applied += a + skipped += s + end + end + + warn "SigApplicator: applied #{applied} runtime type signatures (#{skipped} skipped)" if skipped.positive? + + raise_instrumentation_errors!(errors) + end + + def record_type_error(message) + return if Thread.current[:sig_applicator_suppressed] + + @type_errors << message + end + + def type_errors + @type_errors.dup + end + + # Suppress type error recording for the duration of a block. + # Use for tests that intentionally pass wrong types. + def suppress_errors + Thread.current[:sig_applicator_suppressed] = true + yield + ensure + Thread.current[:sig_applicator_suppressed] = false + end + + private + + def rbi_paths + RbiPaths.manual + end + + def configure_error_handler! + T::Configuration.call_validation_error_handler = lambda do |_sig, opts| + message = opts[:pretty_message] || opts[:message] + value = opts[:value] + type = opts[:type] + + # SimpleDelegator wrappers don't pass Sorbet's is_a? checks because + # they inherit from Delegator, not the wrapped class. Check the + # delegate object against the expected type instead. + if value.is_a?(SimpleDelegator) && type + delegate = value.__getobj__ + SigApplicator.record_type_error(message) unless type.valid?(delegate) + return + end + + # Include location for debugging + location = opts[:location] + full = location ? "#{message}\n Location: #{location}" : message + SigApplicator.record_type_error(full) + end + end + + # Register a Minitest after-run hook that asserts no type errors were + # collected. + def register_summary_hook! + return if @summary_hook_registered + + @summary_hook_registered = true + Minitest.after_run do + raise_recorded_type_errors! + end + end + + def raise_recorded_type_errors! + errors = type_errors + return if errors.empty? + + unique = errors.tally + summary = "SigApplicator: #{errors.size} runtime type errors detected (#{unique.size} unique):\n" + unique.sort_by { |_, count| -count }.each do |msg, count| + summary << " [#{count}x] #{msg}\n" + end + raise Minitest::Assertion, summary.chomp + end + + def raise_instrumentation_errors!(errors) + return if errors.empty? + + summary = "SigApplicator: #{errors.size} methods could not be instrumented:\n" + errors.each { |error| summary << " #{error}\n" } + raise summary.chomp + end + + def apply_scope(node, errors) + return [0, 0] unless node.respond_to?(:nodes) + + class_name = node.name if node.respond_to?(:name) + return [0, 0] unless class_name + return [0, 0] if SKIP_CLASSES.include?(class_name) + + begin + klass = Object.const_get(class_name) + rescue NameError + errors << "#{class_name}: class not found" + return [0, 0] + end + + applied = 0 + skipped = 0 + + node.nodes.each do |child| + case child + when RBI::Method + target = child.is_singleton ? klass.singleton_class : klass + result = apply_method_sig(target, class_name, child, errors, sig_eval_scope: klass) + if result == :skipped + skipped += 1 + elsif result + applied += 1 + end + when *ATTR_NODE_CLASSES + a, s = apply_attr_sig(klass, class_name, child, errors, sig_eval_scope: klass) + applied += a + skipped += s + when RBI::SingletonClass + child.nodes.each do |scn| + case scn + when RBI::Method + result = apply_method_sig( + klass.singleton_class, + class_name, + scn, + errors, + class_method: true, + sig_eval_scope: klass + ) + if result == :skipped + skipped += 1 + elsif result + applied += 1 + end + when *ATTR_NODE_CLASSES + a, s = apply_attr_sig( + klass.singleton_class, + class_name, + scn, + errors, + class_method: true, + sig_eval_scope: klass + ) + applied += a + skipped += s + end + end + end + end + [applied, skipped] + end + + def apply_method_sig(target, class_name, method_node, errors, class_method: false, sig_eval_scope: target) + return false if method_node.sigs.empty? + + method_name = method_node.name.to_sym + singleton_method = class_method || method_node.is_singleton + separator = singleton_method ? '.' : '#' + full_name = "#{class_name}#{separator}#{method_name}" + + return :skipped if SKIP_METHODS.include?(full_name) + + begin + original = target.instance_method(method_name) + rescue NameError + errors << "#{full_name}: method not found" + return false + end + + return :skipped if skip_method?(original, method_node, method_name) + + has_anon_block = anonymous_block?(original) + sig_sources = method_node.sigs.map do |sig| + # RBI::Sig#string serializes back to valid T::Sig DSL source + sig_source = sig.string + # Anonymous block params (def foo(&)) need `"&":` instead of the RBI + # block parameter name. + has_anon_block ? rewrite_block_param(sig_source, method_node, sig) : sig_source + end + + apply_sig_sources_to_method?( + target, + full_name, + method_name, + sig_sources, + errors, + original:, + singleton_method:, + sig_eval_scope: + ) + end + + def apply_attr_sig(target, class_name, attr_node, errors, class_method: false, sig_eval_scope: target) + return [0, 0] if attr_node.sigs.empty? + + singleton_method = class_method + separator = singleton_method ? '.' : '#' + applied = 0 + skipped = 0 + + attr_node.names.each do |attr_name| + attr_method_sig_sources(attr_node, attr_name).each do |method_name, sig_sources| + method_name = method_name.to_sym + full_name = "#{class_name}#{separator}#{method_name}" + + begin + original = target.instance_method(method_name) + rescue NameError + errors << "#{full_name}: method not found" + next + end + + result = apply_sig_sources_to_method?( + target, + full_name, + method_name, + sig_sources, + errors, + original:, + singleton_method:, + sig_eval_scope: + ) + if result == :skipped + skipped += 1 + elsif result + applied += 1 + end + end + end + + [applied, skipped] + end + + def attr_method_sig_sources(attr_node, attr_name) + case attr_node + when RBI::AttrReader + [[attr_name, attr_node.sigs.map(&:string)]] + when RBI::AttrWriter + [["#{attr_name}=", attr_node.sigs.map(&:string)]] + when RBI::AttrAccessor + [ + [attr_name, attr_node.sigs.map(&:string)], + ["#{attr_name}=", writer_sig_sources(attr_node, attr_name)] + ] + else + raise ArgumentError, "Unsupported attr node type: #{attr_node.class}" + end + end + + def writer_sig_sources(attr_node, attr_name) + attr_node.sigs.map do |sig| + return_type = sig.return_type || 'T.untyped' + "sig { params(#{attr_name}: #{return_type}).returns(#{return_type}) }" + end + end + + def apply_sig_sources_to_method?( + target, + full_name, + method_name, + sig_sources, + errors, + original:, + singleton_method:, + sig_eval_scope: + ) + # For inherited methods, copy the method locally so a subclass sig does not + # instrument the parent globally. + inherited_method = original.owner != target + original = define_local_method_copy(target, method_name, original) if inherited_method + + sig_sources.each do |sig_source| + apply_sig_source(sig_eval_scope, target, sig_source, singleton_method) + apply_pending_sig(sig_eval_scope, target, method_name, singleton_method) + + # Force eager sig validation so mismatches are caught now rather than + # causing cascading failures on first call. + method_obj = target.instance_method(method_name) + T::Utils.signature_for_method(method_obj) + rescue StandardError => e + # Restore the original method without the sig wrapper + restore_original_method(target, method_name, original, remove_local_method: inherited_method) + errors << "#{full_name}: #{e.message}" + return false + end + + true + end + + def anonymous_block?(method) + block_param = method.parameters.find { |kind, _| kind == :block } + block_param && (block_param[1].nil? || block_param[1] == :&) + end + + def apply_sig_source(sig_eval_scope, target, sig_source, singleton_method) + if singleton_method + sig_eval_scope.class_eval(<<~RUBY, __FILE__, __LINE__ + 1) + class << self + #{sig_source} # #{sig_source} + end + RUBY + else + target.class_eval(sig_source) + end + end + + # The RBI sig is evaluated after the real method already exists, so Ruby + # will not naturally fire method_added. Call Sorbet's hook directly instead + # of redefining the method to make Ruby fire it. + def apply_pending_sig(sig_eval_scope, target, method_name, singleton_method) + hook_mod = singleton_method ? sig_eval_scope : target + T::Private::Methods._on_method_added(hook_mod, target, method_name) + end + + def define_local_method_copy(target, method_name, original) + visibility = method_visibility(target, method_name) + T::Private::DeclState.current.without_on_method_added do + target.send(:define_method, method_name, original) + target.send(visibility, method_name) + end + target.instance_method(method_name) + end + + def method_visibility(target, method_name) + return :private if target.private_method_defined?(method_name) + return :protected if target.protected_method_defined?(method_name) + + :public + end + + def restore_original_method(target, method_name, original, remove_local_method: false) + T::Private::DeclState.current.without_on_method_added do + if remove_local_method + target.send(:remove_method, method_name) + else + target.send(:define_method, method_name, original) + end + end + end + + # Rewrites the RBI block parameter name to `"&": ` so + # sorbet-runtime matches the anonymous block parameter. + def rewrite_block_param(sig_source, method_node, _sig) + block_param_name = method_node.params.find { |param| param.is_a?(RBI::BlockParam) }&.name + + return sig_source unless block_param_name + + sig_source.sub(/\b#{Regexp.escape(block_param_name)}:\s/, '"&": ') + end + + # Determines whether a method should be skipped for sig application based + # on parameter shape mismatches between the RBI sig and the actual method. + def skip_method?(original, method_node, _method_name) + shape = MethodShape.from(original, method_node) + + # Block param mismatch: methods using yield with no block param, + # or sigs that omit declared blocks. Anonymous blocks (def foo(&)) + # are handled via sig rewriting in apply_method_sig. + return true if shape.actual_block? != shape.rbi_block? + + # Native/extension methods may expose positional parameters without + # names. Sorbet runtime signatures cannot name those parameters without + # adding Ruby wrappers, so keep those RBIs for static checking only. + has_unnamed_params = shape.actual_params.any? { |_kind, name| name.nil? } + return true if has_unnamed_params + + # Synthetic methods (e.g., Data.define generates .new, .[], #initialize, + # #with with a single splat) where the RBI provides typed keyword params + # for better static checking but the runtime signature is incompatible. + non_block_params = shape.actual_non_block_params + all_rest_or_unnamed = non_block_params.all? { |kind, _| kind == :rest || kind == :keyrest } + sig_named_params = method_node.sigs.flat_map { |sig| shape.sig_method_params(sig) } + return true if all_rest_or_unnamed && non_block_params.any? && sig_named_params.any? + + false + end + end +end diff --git a/temporalio/test/support/sig_applicator_test.rb b/temporalio/test/support/sig_applicator_test.rb new file mode 100644 index 00000000..ad0be826 --- /dev/null +++ b/temporalio/test/support/sig_applicator_test.rb @@ -0,0 +1,707 @@ +# frozen_string_literal: true + +require 'delegate' +require 'logger' +require 'minitest/autorun' +require 'rbi' +require 'support/sig_applicator' + +module Support + class SigApplicatorTest < Minitest::Test + def setup + super + @sig_applicator_type_errors = replace_sig_applicator_type_errors([]) + end + + def teardown + replace_sig_applicator_type_errors(@sig_applicator_type_errors) + super + end + + # --- Block param mismatch skips --- + + def test_does_not_skip_anonymous_block_with_sig_block + klass = Class.new do + def foo(&); end + end + method_node = parse_method( + 'class X; sig { params(blk: T.proc.void).void }; def foo(&blk); end; end' + ) + original = klass.instance_method(:foo) + refute skip_method?(original, method_node, :foo) + end + + def test_skips_method_with_block_but_sig_without + klass = Class.new do + def foo(&); end + end + method_node = parse_method('class X; sig { void }; def foo; end; end') + original = klass.instance_method(:foo) + assert skip_method?(original, method_node, :foo) + end + + def test_skips_sig_with_block_but_method_without + klass = Class.new do + def foo; end + end + method_node = parse_method( + 'class X; sig { params(blk: T.proc.void).void }; def foo(&blk); end; end' + ) + original = klass.instance_method(:foo) + assert skip_method?(original, method_node, :foo) + end + + def test_does_not_skip_matching_named_block + klass = Class.new do + def foo(&blk); end # rubocop:disable Naming/BlockForwarding + end + method_node = parse_method( + 'class X; sig { params(blk: T.proc.void).void }; def foo(&blk); end; end' + ) + original = klass.instance_method(:foo) + refute skip_method?(original, method_node, :foo) + end + + def test_does_not_skip_proc_typed_regular_arg + klass = Class.new do + def run_worker(options, next_call); end + end + method_node = parse_method(<<~RBI) + class X + sig { params(options: String, next_call: T.proc.params(arg0: String).returns(Object)).returns(Object) } + def run_worker(options, next_call); end + end + RBI + original = klass.instance_method(:run_worker) + refute skip_method?(original, method_node, :run_worker) + end + + # --- Anonymous block sig rewriting --- + + def test_rewrite_block_param + input = 'sig { params(name: String, blk: T.proc.void).void }' + expected = 'sig { params(name: String, "&": T.proc.void).void }' + method_node = parse_method( + 'class X; sig { params(name: String, blk: T.proc.void).void }; def foo(name, &blk); end; end' + ) + assert_equal expected, rewrite_block_param(input, method_node, method_node.sigs.first) + end + + def test_rewrite_block_param_no_block + input = 'sig { params(name: String).void }' + method_node = parse_method('class X; sig { params(name: String).void }; def foo(name); end; end') + assert_equal input, rewrite_block_param(input, method_node, method_node.sigs.first) + end + + def test_rewrite_block_param_does_not_rewrite_regular_proc_arg + input = 'sig { params(next_call: T.proc.void).void }' + method_node = parse_method( + 'class X; sig { params(next_call: T.proc.void).void }; def foo(next_call); end; end' + ) + assert_equal input, rewrite_block_param(input, method_node, method_node.sigs.first) + end + + # --- Setter / unnamed param skips --- + + def test_skips_attr_writer_with_unnamed_params + klass = Class.new + klass.send(:attr_writer, :bar) + method_node = parse_method( + 'class X; sig { params(value: Integer).void }; def bar=(value); end; end' + ) + original = klass.instance_method(:bar=) + assert skip_method?(original, method_node, :bar=) + end + + def test_does_not_skip_regular_setter + klass = Class.new do + def bar=(value); end + end + method_node = parse_method( + 'class X; sig { params(value: Integer).void }; def bar=(value); end; end' + ) + original = klass.instance_method(:bar=) + refute skip_method?(original, method_node, :bar=) + end + + # --- Synthetic rest-param skips --- + + def test_skips_rest_only_method_with_named_sig_params + klass = Class.new do + def initialize(*args); end + end + method_node = parse_method(<<~RBI) + class X + sig { params(name: String, age: Integer).void } + def initialize(name:, age:); end + end + RBI + original = klass.instance_method(:initialize) + assert skip_method?(original, method_node, :initialize) + end + + def test_does_not_skip_when_params_match + klass = Class.new do + def foo(val1, val2); end + end + method_node = parse_method(<<~RBI) + class X + sig { params(val1: Integer, val2: String).returns(String) } + def foo(val1, val2); end + end + RBI + original = klass.instance_method(:foo) + refute skip_method?(original, method_node, :foo) + end + + def test_does_not_skip_no_param_method + klass = Class.new do + def foo; end + end + method_node = parse_method('class X; sig { returns(String) }; def foo; end; end') + original = klass.instance_method(:foo) + refute skip_method?(original, method_node, :foo) + end + + def test_register_summary_hook_uses_after_run + original_registered = SigApplicator.instance_variable_get(:@summary_hook_registered) + hooks = [] + minitest_singleton_class = Minitest.singleton_class + original_after_run = Minitest.method(:after_run) + minitest_singleton_class.send(:define_method, :after_run) { |&block| hooks << block } + SigApplicator.instance_variable_set(:@summary_hook_registered, false) + + SigApplicator.send(:register_summary_hook!) + + assert_equal 1, hooks.size + assert SigApplicator.instance_variable_get(:@summary_hook_registered) + refute Object.const_defined?(:ZZZSigApplicatorTest) + ensure + minitest_singleton_class&.send(:define_method, :after_run, original_after_run) + SigApplicator.instance_variable_set(:@summary_hook_registered, original_registered) + end + + def test_raise_recorded_type_errors_reports_unique_counts + replace_sig_applicator_type_errors(['first error', 'second error', 'first error']) + + error = assert_raises(Minitest::Assertion) do + SigApplicator.send(:raise_recorded_type_errors!) + end + + assert_includes error.message, 'SigApplicator: 3 runtime type errors detected (2 unique):' + assert_includes error.message, ' [2x] first error' + assert_includes error.message, ' [1x] second error' + end + + def test_apply_all_raises_when_signature_cannot_be_instrumented + test_class = Class.new do + extend T::Sig + + def self.foo(value); end + end + Support.const_set(:SigApplicatorApplyAllTest, test_class) + + tree = RBI::Parser.parse_string(<<~RBI) + class Support::SigApplicatorApplyAllTest + sig { params(other: String).void } + def self.foo(value); end + end + RBI + + parser = RBI::Parser.singleton_class + original_parse_file = RBI::Parser.method(:parse_file) + parser.send(:define_method, :parse_file) { |_path| tree } + + error = assert_raises(RuntimeError) do + with_sig_applicator_rbi_paths(['test.rbi']) { SigApplicator.apply_all! } + end + assert_includes error.message, 'SigApplicator: 1 methods could not be instrumented:' + assert_includes error.message, 'Support::SigApplicatorApplyAllTest.foo:' + ensure + parser.send(:define_method, :parse_file, original_parse_file) + if Support.const_defined?(:SigApplicatorApplyAllTest, false) + Support.send(:remove_const, :SigApplicatorApplyAllTest) + end + end + + def test_apply_all_reads_all_rbi_paths + test_class = Class.new do + def self.foo(value) + value + end + + def self.bar(value) + value + end + end + Support.const_set(:SigApplicatorMultiFileTest, test_class) + + trees = { + 'one.rbi' => RBI::Parser.parse_string(<<~RBI), + class Support::SigApplicatorMultiFileTest + sig { params(value: String).returns(String) } + def self.foo(value); end + end + RBI + 'two.rbi' => RBI::Parser.parse_string(<<~RBI) + class Support::SigApplicatorMultiFileTest + sig { params(value: String).returns(String) } + def self.bar(value); end + end + RBI + } + parsed_paths = [] + + parser = RBI::Parser.singleton_class + original_parse_file = RBI::Parser.method(:parse_file) + parser.send(:define_method, :parse_file) do |path| + parsed_paths << path + trees.fetch(path) + end + + with_sig_applicator_rbi_paths(trees.keys) { SigApplicator.apply_all! } + + assert_equal trees.keys, parsed_paths + assert_empty SigApplicator.type_errors + ensure + parser.send(:define_method, :parse_file, original_parse_file) + if Support.const_defined?(:SigApplicatorMultiFileTest, false) + Support.send(:remove_const, :SigApplicatorMultiFileTest) + end + end + + def test_apply_all_applies_attr_reader_signature + test_class = Class.new + test_class.send(:define_method, :initialize) do |name| + @name = name + end + test_class.send(:attr_reader, :name) + Support.const_set(:SigApplicatorAttrReaderTest, test_class) + + tree = RBI::Parser.parse_string(<<~RBI) + class Support::SigApplicatorAttrReaderTest + sig { returns(String) } + attr_reader :name + end + RBI + + parser = RBI::Parser.singleton_class + original_parse_file = RBI::Parser.method(:parse_file) + parser.send(:define_method, :parse_file) { |_path| tree } + + with_sig_applicator_rbi_paths(['test.rbi']) { SigApplicator.apply_all! } + test_class.send(:new, 123).name + + assert_includes SigApplicator.type_errors.join("\n"), 'Return value: Expected type String, got type Integer' + ensure + parser.send(:define_method, :parse_file, original_parse_file) + if Support.const_defined?(:SigApplicatorAttrReaderTest, false) + Support.send(:remove_const, :SigApplicatorAttrReaderTest) + end + end + + def test_apply_all_applies_attr_writer_signature + test_class = Class.new + test_class.send(:attr_writer, :name) + Support.const_set(:SigApplicatorAttrWriterTest, test_class) + + tree = RBI::Parser.parse_string(<<~RBI) + class Support::SigApplicatorAttrWriterTest + sig { params(name: String).returns(Object) } + attr_writer :name + end + RBI + + parser = RBI::Parser.singleton_class + original_parse_file = RBI::Parser.method(:parse_file) + parser.send(:define_method, :parse_file) { |_path| tree } + + with_sig_applicator_rbi_paths(['test.rbi']) { SigApplicator.apply_all! } + test_class.new.name = 123 + + assert_includes SigApplicator.type_errors.join("\n"), "Parameter 'name': Expected type String, got type Integer" + ensure + parser.send(:define_method, :parse_file, original_parse_file) + if Support.const_defined?(:SigApplicatorAttrWriterTest, false) + Support.send(:remove_const, :SigApplicatorAttrWriterTest) + end + end + + def test_apply_all_applies_attr_accessor_signature + test_class = Class.new + test_class.send(:attr_accessor, :count) + Support.const_set(:SigApplicatorAttrAccessorTest, test_class) + + tree = RBI::Parser.parse_string(<<~RBI) + class Support::SigApplicatorAttrAccessorTest + sig { returns(Integer) } + attr_accessor :count + end + RBI + + parser = RBI::Parser.singleton_class + original_parse_file = RBI::Parser.method(:parse_file) + parser.send(:define_method, :parse_file) { |_path| tree } + + with_sig_applicator_rbi_paths(['test.rbi']) { SigApplicator.apply_all! } + + instance = test_class.new + instance.count = 'bad' + instance.count + + errors = SigApplicator.type_errors.join("\n") + assert_includes errors, "Parameter 'count': Expected type Integer, got type String" + assert_includes errors, 'Return value: Expected type Integer, got type String' + ensure + parser.send(:define_method, :parse_file, original_parse_file) + if Support.const_defined?(:SigApplicatorAttrAccessorTest, false) + Support.send(:remove_const, :SigApplicatorAttrAccessorTest) + end + end + + def test_apply_method_sig_supports_anonymous_block_with_named_rbi_block + klass = Class.new do + extend T::Sig + + def foo(&); end + end + method_node = parse_method( + 'class X; sig { params(blk: T.proc.void).void }; def foo(&blk); end; end' + ) + errors = [] + + assert apply_method_sig(klass, 'X', method_node, errors, sig_eval_scope: klass) + assert_empty errors + end + + def test_apply_method_sig_supports_proc_typed_regular_arg + klass = Class.new do + extend T::Sig + + def run_worker(options, next_call) + next_call.call(options) + end + end + method_node = parse_method(<<~RBI) + class X + sig { params(options: String, next_call: T.proc.params(arg0: String).returns(Integer)).returns(Integer) } + def run_worker(options, next_call); end + end + RBI + errors = [] + + assert apply_method_sig(klass, 'X', method_node, errors, sig_eval_scope: klass) + assert_empty errors + assert_equal 2, klass.new.run_worker('ok', ->(_value) { 2 }) + end + + def test_apply_method_sig_does_not_emit_extra_method_added_events + method_added_events = [] + klass = Class.new do + extend T::Sig + + define_singleton_method(:method_added) { |name| method_added_events << name } + + def foo + 'ok' + end + end + method_added_events.clear + method_node = parse_method('class X; sig { returns(String) }; def foo; end; end') + errors = [] + + assert apply_method_sig(klass, 'X', method_node, errors, sig_eval_scope: klass) + assert_empty errors + assert_equal 'ok', klass.new.foo + assert_equal method_added_events.select { |name| name == :foo }, method_added_events + # Sorbet replaces the method twice, we should not add to this + assert_equal method_added_events.size, 2 + end + + def test_apply_method_sig_restores_original_method_when_instrumentation_fails + klass = Class.new do + extend T::Sig + + def foo(value) + "original: #{value}" + end + end + original = klass.instance_method(:foo) + method_node = parse_method(<<~RBI) + class X + sig { params(other: String).returns(String) } + def foo(other); end + end + RBI + errors = [] + + refute apply_method_sig(klass, 'X', method_node, errors, sig_eval_scope: klass) + assert_includes errors.join("\n"), 'The declaration for `foo` is missing parameter(s): value' + assert_equal original, klass.instance_method(:foo) + assert_equal 'original: ok', klass.new.foo('ok') + end + + def test_apply_method_sig_catches_incompatible_override_after_inherited_method_sig + base_class = Class.new do + def to_h + { value: 'base' } + end + end + inherited_method_class = Class.new(base_class) { extend T::Sig } + override_class = Class.new(inherited_method_class) do + extend T::Sig + + def to_h + { 'profile' => { value: 'override' } } + end + end + + Support.const_set(:SigApplicatorInheritedMethodSigTest, inherited_method_class) + Support.const_set(:SigApplicatorIncompatibleOverrideTest, override_class) + + inherited_method_node = parse_method(<<~RBI) + class Support::SigApplicatorInheritedMethodSigTest + sig { returns(T::Hash[Symbol, T.untyped]) } + def to_h; end + end + RBI + override_method_node = parse_method(<<~RBI) + class Support::SigApplicatorIncompatibleOverrideTest + sig { returns(T::Hash[String, T::Hash[Symbol, T.untyped]]) } + def to_h; end + end + RBI + + errors = [] + assert apply_method_sig( + inherited_method_class, + 'Support::SigApplicatorInheritedMethodSigTest', + inherited_method_node, + errors, + sig_eval_scope: inherited_method_class + ) + assert_empty errors + + refute apply_method_sig( + override_class, + 'Support::SigApplicatorIncompatibleOverrideTest', + override_method_node, + errors, + sig_eval_scope: override_class + ) + assert_includes errors.join("\n"), 'Incompatible return type in signature for override of method `to_h`' + ensure + if Support.const_defined?(:SigApplicatorInheritedMethodSigTest, false) + Support.send(:remove_const, :SigApplicatorInheritedMethodSigTest) + end + if Support.const_defined?(:SigApplicatorIncompatibleOverrideTest, false) + Support.send(:remove_const, :SigApplicatorIncompatibleOverrideTest) + end + end + + def test_apply_method_sig_for_inherited_method_does_not_wrap_original_owner + original_delegator_initialize = Delegator.instance_method(:initialize) + inherited_method_class = Class.new(SimpleDelegator) { extend T::Sig } + child_class = Class.new(inherited_method_class) + child_class.send(:define_method, :initialize) do |obj:, marker:| + @marker = marker + super(obj) + end + child_class.send(:attr_reader, :marker) + Support.const_set(:SigApplicatorDelegatorSigTest, inherited_method_class) + + inherited_method_node = parse_method(<<~RBI) + class Support::SigApplicatorDelegatorSigTest + sig { params(obj: ::Logger).void } + def initialize(obj); end + end + RBI + + errors = [] + assert apply_method_sig( + inherited_method_class, + 'Support::SigApplicatorDelegatorSigTest', + inherited_method_node, + errors, + sig_eval_scope: inherited_method_class + ) + assert_empty errors + + assert_equal original_delegator_initialize, Delegator.instance_method(:initialize) + assert_equal inherited_method_class, inherited_method_class.instance_method(:initialize).owner + + child = child_class.send(:new, obj: Logger.new(nil), marker: :ok) + assert_equal :ok, child.marker + assert_instance_of Logger, child.__getobj__ + ensure + if Support.const_defined?(:SigApplicatorDelegatorSigTest, false) + Support.send(:remove_const, :SigApplicatorDelegatorSigTest) + end + end + + def test_apply_method_sig_preserves_inherited_method_visibility + base_class = Class.new + base_class.define_method(:protected_value) { 'protected' } + base_class.define_method(:private_value) { 'private' } + base_class.send(:protected, :protected_value) + base_class.send(:private, :private_value) + inherited_method_class = Class.new(base_class) { extend T::Sig } + Support.const_set(:SigApplicatorVisibilityTest, inherited_method_class) + + protected_node = parse_method(<<~RBI) + class Support::SigApplicatorVisibilityTest + sig { returns(String) } + def protected_value; end + end + RBI + private_node = parse_method(<<~RBI) + class Support::SigApplicatorVisibilityTest + sig { returns(String) } + def private_value; end + end + RBI + + errors = [] + assert apply_method_sig( + inherited_method_class, + 'Support::SigApplicatorVisibilityTest', + protected_node, + errors, + sig_eval_scope: inherited_method_class + ) + assert apply_method_sig( + inherited_method_class, + 'Support::SigApplicatorVisibilityTest', + private_node, + errors, + sig_eval_scope: inherited_method_class + ) + assert_empty errors + + assert inherited_method_class.protected_method_defined?(:protected_value) + assert inherited_method_class.private_method_defined?(:private_value) + refute inherited_method_class.public_method_defined?(:protected_value) + refute inherited_method_class.public_method_defined?(:private_value) + ensure + if Support.const_defined?(:SigApplicatorVisibilityTest, false) + Support.send(:remove_const, :SigApplicatorVisibilityTest) + end + end + + def test_apply_method_sig_removes_local_copy_when_inherited_instrumentation_fails + base_class = Class.new do + def foo(value) + "original: #{value}" + end + end + inherited_method_class = Class.new(base_class) { extend T::Sig } + Support.const_set(:SigApplicatorInheritedRestoreTest, inherited_method_class) + + method_node = parse_method(<<~RBI) + class Support::SigApplicatorInheritedRestoreTest + sig { params(other: String).returns(String) } + def foo(other); end + end + RBI + + errors = [] + refute apply_method_sig( + inherited_method_class, + 'Support::SigApplicatorInheritedRestoreTest', + method_node, + errors, + sig_eval_scope: inherited_method_class + ) + assert_includes errors.join("\n"), 'The declaration for `foo` is missing parameter(s): value' + assert_equal base_class, inherited_method_class.instance_method(:foo).owner + assert_equal 'original: ok', inherited_method_class.new.foo('ok') + ensure + if Support.const_defined?(:SigApplicatorInheritedRestoreTest, false) + Support.send(:remove_const, :SigApplicatorInheritedRestoreTest) + end + end + + def test_apply_method_sig_resolves_singleton_sig_constants_in_class_namespace + klass = Class.new do + extend T::Sig + + class << self + extend T::Sig + end + + def self.foo(value); end + end + klass.const_set(:Inner, Data.define(:value)) + Support.const_set(:SigApplicatorSingletonScopeTest, klass) + method_node = parse_method(<<~RBI) + class Support::SigApplicatorSingletonScopeTest + sig { params(value: Inner).void } + def self.foo(value); end + end + RBI + errors = [] + + assert apply_method_sig( + klass.singleton_class, + 'Support::SigApplicatorSingletonScopeTest', + method_node, + errors, + sig_eval_scope: klass + ) + assert_empty errors + ensure + if Support.const_defined?(:SigApplicatorSingletonScopeTest, false) + Support.send(:remove_const, :SigApplicatorSingletonScopeTest) + end + end + + private + + def parse_method(source) + tree = RBI::Parser.parse_string(source) + klass = tree.nodes.first + klass.nodes.find { |n| n.is_a?(RBI::Method) } + end + + def skip_method?(original, method_node, method_name) + SigApplicator.send(:skip_method?, original, method_node, method_name) + end + + def rewrite_block_param(sig_source, method_node, sig) + SigApplicator.send(:rewrite_block_param, sig_source, method_node, sig) + end + + def apply_method_sig(target, class_name, method_node, errors, sig_eval_scope:) + SigApplicator.send( + :apply_method_sig, + target, + class_name, + method_node, + errors, + sig_eval_scope: + ) + end + + def attr_method_sig_sources(attr_node, attr_name) + SigApplicator.send(:attr_method_sig_sources, attr_node, attr_name) + end + + def replace_sig_applicator_type_errors(new_errors) + errors = SigApplicator.instance_variable_get(:@type_errors) + previous = errors.dup + errors.replace(new_errors) + previous + end + + def with_sig_applicator_rbi_paths(paths) + singleton_class = SigApplicator.singleton_class + original = singleton_class.instance_method(:rbi_paths) + singleton_class.send(:define_method, :rbi_paths) { paths } + singleton_class.send(:private, :rbi_paths) + yield + ensure + singleton_class.send(:define_method, :rbi_paths, original) + singleton_class.send(:private, :rbi_paths) + end + end +end diff --git a/temporalio/test/test.rb b/temporalio/test/test.rb index dcce1a3f..4e9ec4d9 100644 --- a/temporalio/test/test.rb +++ b/temporalio/test/test.rb @@ -15,6 +15,21 @@ require 'timeout' require 'workflow_utils' +if ENV['TEMPORAL_SORBET_RUNTIME_CHECK'] + # Load modules that are lazy-loaded so their types can be instrumented + require 'temporalio/common_enums' + require 'temporalio/contrib/open_telemetry' + require 'temporalio/converters/payload_codec' + require 'temporalio/env_config' + require 'temporalio/simple_plugin' + require 'temporalio/worker/interceptor' + require 'temporalio/worker/workflow_replayer' + require 'temporalio/workflow' + + require 'support/sig_applicator' + SigApplicator.apply_all! +end + # require 'memory_profiler' # MemoryProfiler.start # Minitest.after_run do diff --git a/temporalio/test/type_signature_coverage_test.rb b/temporalio/test/type_signature_coverage_test.rb new file mode 100644 index 00000000..7c1d6b79 --- /dev/null +++ b/temporalio/test/type_signature_coverage_test.rb @@ -0,0 +1,37 @@ +# frozen_string_literal: true + +require 'minitest/autorun' +require 'pathname' + +class TypeSignatureCoverageTest < Minitest::Test + ROOT = Pathname.new(File.expand_path('..', __dir__ || raise)) + LIB_ROOT = ROOT.join('lib') + RBI_ROOT = ROOT.join('rbi') + SIG_ROOT = ROOT.join('sig') + + def test_ruby_files_have_matching_rbs_files + missing_paths = missing_signature_paths(SIG_ROOT, '.rbs') + assert_empty missing_paths, "Ruby files missing RBS files:\n#{missing_paths.join("\n")}" + end + + def test_ruby_files_have_matching_rbi_files + missing_paths = missing_signature_paths(RBI_ROOT, '.rbi') + assert_empty missing_paths, "Ruby files missing RBI files:\n#{missing_paths.join("\n")}" + end + + private + + def ruby_paths + @ruby_paths ||= relative_stems(LIB_ROOT, '**/*.rb') + end + + def missing_signature_paths(root, extension) + ruby_paths - relative_stems(root, "**/*#{extension}") + end + + def relative_stems(root, pattern) + Dir.glob(root.join(pattern).to_s).map do |path| + Pathname.new(path).relative_path_from(root).sub_ext('').to_s + end.sort + end +end diff --git a/temporalio/test/worker_activity_test.rb b/temporalio/test/worker_activity_test.rb index e0ccaaa5..ff6cf15f 100644 --- a/temporalio/test/worker_activity_test.rb +++ b/temporalio/test/worker_activity_test.rb @@ -168,11 +168,20 @@ class NotAnActivity # rubocop:disable Lint/EmptyClass def test_not_an_activity error = assert_raises(ArgumentError) do - Temporalio::Worker.new( - client: env.client, - task_queue: "tq-#{SecureRandom.uuid}", - activities: [NotAnActivity] - ) + # Intentionally passing a non-activity class to test validation. + # Suppress sorbet runtime errors since the wrong type is deliberate. + block = proc do + Temporalio::Worker.new( + client: env.client, + task_queue: "tq-#{SecureRandom.uuid}", + activities: [NotAnActivity] + ) + end + if defined?(SigApplicator) + SigApplicator.suppress_errors { block.call } + else + block.call + end end assert error.message.end_with?('does not extend Temporalio::Activity::Definition') end @@ -272,24 +281,26 @@ def execute end def test_info + # The hash is round-tripped through the data converter so non-primitive + # values (Time, RetryPolicy) are serialized to strings. Use string keys + # from the deserialized JSON to check values directly. info_hash = execute_activity(InfoActivity) - info = Temporalio::Activity::Info.new(**info_hash) # steep:ignore - refute_nil info.activity_id - assert_equal 'InfoActivity', info.activity_type - assert_equal 1, info.attempt - refute_nil info.current_attempt_scheduled_time - assert_equal false, info.local? - refute_nil info.retry_policy - refute_nil info.schedule_to_close_timeout - refute_nil info.scheduled_time - refute_nil info.start_to_close_timeout - refute_nil info.started_time - refute_nil info.task_queue - refute_nil info.task_token - refute_nil info.workflow_id - assert_equal env.client.namespace, info.workflow_namespace - refute_nil info.workflow_run_id - assert_equal 'kitchen_sink', info.workflow_type + refute_nil info_hash['activity_id'] + assert_equal 'InfoActivity', info_hash['activity_type'] + assert_equal 1, info_hash['attempt'] + refute_nil info_hash['current_attempt_scheduled_time'] + assert_equal false, info_hash['local?'] + refute_nil info_hash['retry_policy'] + refute_nil info_hash['schedule_to_close_timeout'] + refute_nil info_hash['scheduled_time'] + refute_nil info_hash['start_to_close_timeout'] + refute_nil info_hash['started_time'] + refute_nil info_hash['task_queue'] + refute_nil info_hash['task_token'] + refute_nil info_hash['workflow_id'] + assert_equal env.client.namespace, info_hash['workflow_namespace'] + refute_nil info_hash['workflow_run_id'] + assert_equal 'kitchen_sink', info_hash['workflow_type'] end class CancellationActivity < Temporalio::Activity::Definition diff --git a/temporalio/test/worker_workflow_test.rb b/temporalio/test/worker_workflow_test.rb index 7860a14d..c8f95df1 100644 --- a/temporalio/test/worker_workflow_test.rb +++ b/temporalio/test/worker_workflow_test.rb @@ -668,7 +668,12 @@ def test_stack_trace line, = line.partition(':in') line end.sort - end.sort + end + # Sorbet runtime sig wrappers add extra stack frames that appear as + # empty entries after filtering. Remove them when running with runtime + # type checking. + actual_traces.reject!(&:empty?) if ENV['TEMPORAL_SORBET_RUNTIME_CHECK'] + actual_traces.sort! expected_traces = handle.query(StackTraceWorkflow.expected_traces).map(&:sort).sort # steep:ignore assert_equal expected_traces, actual_traces end