commands.yaml

# This document is automatically parsed.
# Follow these rules.

# IN-HOUSE STYLE

# * Wording and grammar:
#   * Run a spell check.
#   * Be clear and concise.
#   * Don't reword the command in the summary. Use distinct supplementary language.
#     * Yes: temporal workflow delete: Remove Workflow Execution
#     * No: temporal workflow delete: Delete Workflow
#   * Re-use and adapt existing wording and phrases wherever possible.
#   * Word command summaries as if they began "This command will..."
#     Use sentence casing for the summary.
#   * ID is fully capitalized in text ("the Workflow ID") and Id in
#     [metasyntax](https://en.wikipedia.org/wiki/Metasyntactic_variable) (YourWorkflowId).
# * Avoid parentheticals unless absolutely necessary.

# * Wrapping:
#   * Assume a user-visible line length of 80 characters max. `fmt -w 78` can help.
#     * Long descriptions must be pre-wrapped.
#   * When declaring Options follow the wrapping style used elsewhere in this file.
#     Splitting the items into multiple lines improves maintainability with clearer diffs.

# * Punctuation:
#   * End description blocks with a period.
#     Do _not_ use periods for summaries.
#   * Introduce triple-quoted code-fenced samples with a colons.
#     Avoid using 'for example' unless there's no other way to introduce code.

# * Code, flags, and keys:
#   * Demonstrate at least one example invocation of the command in every long description.
#   * Include the most commonly used patterns in long descriptions so users don't
#     have to call help at multiple invocation levels.
#   * Avoid deprecated period-delineated versions of environment-specific keys.
#     * Yes:
#           ```
#           temporal env set \
#               --env prod \
#               --key tls-cert-path \
#               --value /home/my-user/certs/cluster.cert
#           ```
#     * No: `temporal env set prod.tls-cert-path /home/my-user/certs/cluster.cert`.
#   * Split invocation samples to multiple lines.
#     Use one option or flag per line, as in the above example.
#     Use a single space and a backslash to continue the invocation.
#     Use 4-space indentation.
#   * Always use long options and flags for invocation examples.
#     * Yes: `--namespace`
#     * No:  `-n`
#   * When commands have a single command-level option, include it the mandatory example.
#   * Use square bracket overviews to present how complex commands will be used.
#     * Yes: temporal operator [command] [subcommand] [options]
#     Commands with subcommands can't be run on their own unless
#     subcommands-optional is set to true.
#     Because of this, always use full command examples.
#   * Use square brackets to highlight optional elements, especially when long
#     descriptions would suffer from two very similar command invocations.
#     * Yes: temporal operator cluster describe [--detail]
#   * Use YourEnvironment, YourNamespace, etc. as unquoted metasyntactic variable
#     stand-ins.
#     Respectful metasyntax describes the role of the stand-in.
#     * Yes: --workflow-id YourWorkflowId
#     * No: --workflow-id your-work-id, --workflow-id "
#   * For JSON input, use single quotes to encase interior double quotes.
#     Otherwise, in the rare case it is needed, prefer double quotes.
#   * When presenting options use a space rather than equal to set them.
#     This is more universally supported and consistent with POSIX guidelines.
#     * Yes: `temporal command --namespace YourNamespace`.
#     * No: `temporal command --namespace=YourNamespace`.
#     Note: in this utility's current incarnation, Boolean options must be
#     set with an equal sign.
#     Since Booleans can be treated like flags, avoid using assigned values in samples.
#     * Yes: `--detail`
#     * No: `--detail=true`

# For options and flags:

# * When options and flags can be passed multiple times, say so explicitly in
#   the usage text: "Can be passed multiple times."
# * Never rely on the flag type (e.g. `string`, `bool`, etc.) being shown to the user.
#   It is replaced/hidden when a `META-VARIABLE` is used.
# * Where possible, use a `META-VARIABLE` (all caps and wrapped in `\``s) to
#   describe/reference content passed to an option.
# * Limit `code spans` to meta-variables.
#   To reference other options or specify literal values, use double quotes.

# COMMAND ENTRY OVERVIEW

# A Command entry uses the following format:
# - name: The full command path with parent commands. (string)
#   summary: A concise command explanation. (string)
#   description: A detailed command explanation. (string)
#   has-init: invokes `initCommand` method. (bool)
#   exact-args: Require this exact number of args. (int)
#   maximum-args: Require this maximum number of args. (int)
#   ignores-missing-env: Ignore missing environment variables. (bool)
#   subcommands-optional: Allow command to be run even when it has subcommands. (bool)
#   options: A list of options. (Option[])
#     - name: The option name. (string)
#       type: The option type. (string)
#       display-type: Optional custom description for displaying the type in the help (string)
#       description: The option description. (string)
#       required: Whether the option is required. (bool)
#       short: The single letter short version of name (i.e. a for address). (string)
#       implied-env: Documents the environment variable in the help text.
#         Environment variable binding must be done manually in code.
#       default: The default value. No default means zero value of the type. (string)
#       enum-values: A list of possible values for the string-enum type. (string[])
#       aliases: A list of aliases for the option. (string[])
#       hidden: Hides the option from help output. (bool)
#   option-sets: A list of option sets. (string[])

# * name, summary, and descrption are required fields. All other fields are optional.
# * Available option types are `bool`, `duration`, `int`, `float`, `string`, `string[]`,
#   `string-enum`, `string-enum[]`, or `timestamp`.
# * Include a new-line after each command entry.

# OPTION SET OVERVIEW

# An options set declaration is the equivalent of pasting those options into the
# bulleted options list.

# - name: The name of the option set. (string)
#   options: A list of options. Same template as Command options above (Option[])

# Options that are similar but slightly different don't need to be in option sets.
# Reserve option sets for when the behavior of the option is the same across commands.

# * Include a new-line after each option set.

commands:
  - name: temporal
    summary: Temporal command-line interface and development server
    description: |
      The Temporal CLI manages, monitors, and debugs Temporal apps. It lets you run
      a local Temporal Service, start Workflow Executions, pass messages to running
      Workflows, inspect state, and more.

      * Start a local development service:
            `temporal server start-dev`
      * View help: pass `--help` to any command:
            `temporal activity complete --help`
    has-init: true
    option-sets:
      - common

  - name: temporal activity
    summary: Operate on Activity Executions
    description: |
      Perform operations on Activity Executions.
    option-sets:
      - client
    docs:
      description-header: >-
        Learn how to use Temporal Activity commands to perform operations on Activity Executions.
      keywords:
        - activity
        - activity start
        - activity execute
        - activity describe
        - activity list
        - activity count
        - activity cancel
        - activity terminate
        - activity execution
        - activity complete
        - activity update-options
        - activity fail
        - activity pause
        - activity unpause
        - activity reset
        - cli reference
        - cli-feature
        - command-line-interface-cli
        - temporal cli
      tags:
        - Activities
        - Temporal CLI

  - name: temporal activity cancel
    summary: Request cancellation of a Standalone Activity (Experimental)
    description: |
      Request cancellation of a Standalone Activity.

      ```
      temporal activity cancel \
          --activity-id YourActivityId
      ```

      Requesting cancellation transitions the Activity's run state
      to CancelRequested. If the Activity is heartbeating, a
      cancellation error will be raised when the next heartbeat
      response is received; if the Activity allows this error to
      propagate, the Activity transitions to canceled status.
    option-sets:
      - activity-reference
    options:
      - name: reason
        type: string
        description: Reason for cancellation.

  - name: temporal activity complete
    summary: Mark an activity as completed successfully with a result
    description: |
      Complete an Activity, marking it as successfully finished. Specify the
      Activity ID and include a JSON result for the returned value:

      ```
      temporal activity complete \
          --activity-id YourActivityId \
          --workflow-id YourWorkflowId \
          --input '{"YourResultKey": "YourResultVal"}'
      ```
    options:
      - name: activity-id
        short: a
        type: string
        description: |
          Activity ID. This may be the ID of an Activity
          invoked by a Workflow, or of a Standalone Activity.
        required: true
      - name: workflow-id
        type: string
        short: w
        description: |
          Workflow ID. Required for workflow Activities.
          Omit for Standalone Activities.
      - name: run-id
        type: string
        short: r
        description: |
          Run ID. For workflow Activities (when --workflow-id is
          provided), this is the Workflow Run ID. For Standalone
          Activities, this is the Activity Run ID.
    option-sets:
      - payload-input

  - name: temporal activity count
    summary: Count Standalone Activities matching a query (Experimental)
    description: |
      Return a count of Standalone Activities. Use `--query` to filter
      the activities to be counted.

      ```
      temporal activity count \
          --query 'ActivityType="YourActivity"'
      ```

      Visit https://docs.temporal.io/visibility to read more about
      Search Attributes and queries.
    options:
      - name: query
        type: string
        short: q
        description: |
          Query to filter Activity Executions to count.

  - name: temporal activity describe
    summary: Show detailed info for a Standalone Activity (Experimental)
    description: |
      Display information about a Standalone Activity.

      ```
      temporal activity describe \
          --activity-id YourActivityId
      ```
    option-sets:
      - activity-reference
    options:
      - name: raw
        type: bool
        description: Print properties without changing their format.

  - name: temporal activity execute
    summary: Start a new Standalone Activity and wait for its result (Experimental)
    description: |
      Start a new Standalone Activity and block until it completes.
      The result is output to stdout.

      ```
      temporal activity execute \
          --activity-id YourActivityId \
          --type YourActivity \
          --task-queue YourTaskQueue \
          --start-to-close-timeout 30s \
          --input '{"some-key": "some-value"}'
      ```
    option-sets:
      - activity-start
      - payload-input

  - name: temporal activity fail
    summary: Mark an Activity as completed unsuccessfully with an error
    description: |
      Fail an Activity, marking it as having encountered an error:

      ```
      temporal activity fail \
          --activity-id YourActivityId \
          --workflow-id YourWorkflowId
      ```
    options:
      - name: activity-id
        short: a
        type: string
        description: |
          Activity ID. This may be the ID of an Activity
          invoked by a Workflow, or of a Standalone Activity.
        required: true
      - name: workflow-id
        type: string
        short: w
        description: |
          Workflow ID. Required for workflow Activities.
          Omit for Standalone Activities.
      - name: run-id
        type: string
        short: r
        description: |
          Run ID. For workflow Activities (when --workflow-id is
          provided), this is the Workflow Run ID. For Standalone
          Activities, this is the Activity Run ID.
      - name: detail
        type: string
        description: |
          Failure detail (JSON). Attached as the failure details
          payload.
      - name: reason
        type: string
        description: |
          Failure reason. Attached as the failure message.

  - name: temporal activity list
    summary: List Standalone Activities matching a query (Experimental)
    description: |
      List Standalone Activities. Use `--query` to filter results.

      ```
      temporal activity list \
          --query 'ActivityType="YourActivity"'
      ```

      Visit https://docs.temporal.io/visibility to read more about
      Search Attributes and queries.
    options:
      - name: query
        short: q
        type: string
        description: |
          Query to filter the Activity Executions to list.
      - name: limit
        type: int
        description: |
          Maximum number of Activity Executions to display.
      - name: page-size
        type: int
        description: |
          Maximum number of Activity Executions to fetch
          at a time from the server.

  - name: temporal activity update-options
    summary: Change the values of options affecting a running Activity
    description: |
      Update the options of a running Activity that were passed into it from
      a Workflow. Updates are incremental, only changing the specified options.
      Not supported for Standalone Activities.

      For example:

      ```
      temporal activity update-options \
          --activity-id YourActivityId \
          --workflow-id YourWorkflowId \
          --task-queue NewTaskQueueName \
          --schedule-to-close-timeout DURATION \
          --schedule-to-start-timeout DURATION \
          --start-to-close-timeout DURATION \
          --heartbeat-timeout DURATION \
          --retry-initial-interval DURATION \
          --retry-maximum-interval DURATION \
          --retry-backoff-coefficient NewBackoffCoefficient \
          --retry-maximum-attempts NewMaximumAttempts
      ```

      You may follow this command with `temporal activity reset`, and the new values will apply after the reset.

      Either `--activity-id` or `--query` must be specified.

      Activity options can be updated in bulk with a visibility query list filter:

      ```
      temporal activity update-options \
          --query 'WorkflowType="YourWorkflow"' \
          --task-queue NewTaskQueueName
      ```
    options:
      - name: activity-id
        short: a
        type: string
        description: |
          The Activity ID to update options. Mutually exclusive with `--query`. Requires `--workflow-id` to be specified.
      - name: task-queue
        type: string
        description: Name of the task queue for the Activity.
      - name: schedule-to-close-timeout
        type: duration
        description: |
          Indicates how long the caller is willing to wait for an activity
          completion.
          Limits how long retries will be attempted.
      - name: schedule-to-start-timeout
        type: duration
        description: |
          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 the schedule-to-close timeout or workflow execution
          timeout if not specified.
      - name: start-to-close-timeout
        type: duration
        description: |
          Maximum time an activity is allowed to execute after being picked up
          by a worker. This timeout is always retryable.
      - name: heartbeat-timeout
        type: duration
        description: |
          Maximum permitted time between successful worker heartbeats.
      - name: retry-initial-interval
        type: duration
        description: |
          Interval of the first retry. If retryBackoffCoefficient is 1.0 then it
          is used for all retries.
      - name: retry-maximum-interval
        type: duration
        description: |
          Maximum interval between retries. Exponential backoff leads to
          interval increase.
          This value is the cap of the increase.
      - name: retry-backoff-coefficient
        type: float
        description: |
          Coefficient used to calculate the next retry interval.
          The next retry interval is previous interval multiplied by the backoff
          coefficient.
          Must be 1 or larger.
      - name: retry-maximum-attempts
        type: int
        description: |
          Maximum number of attempts. When exceeded the retries stop even if not
          expired yet.
          Setting this value to 1 disables retries. Setting this value to 0
          means unlimited attempts(up to the timeouts).
      - name: restore-original-options
        type: bool
        description: Restore the original options of the activity.
    option-sets:
      - single-activity-or-batch

  - name: temporal activity pause
    summary: Pause an Activity
    description: |
      Pause an Activity. Not supported for Standalone Activities.

      If the Activity is not currently running (e.g. because it previously
      failed), it will not be run again until it is unpaused.

      However, if the Activity is currently running, it will run until the next
      time it fails, completes, or times out, at which point the pause will kick in.

      If the Activity is on its last retry attempt and fails, the failure will
      be returned to the caller, just as if the Activity had not been paused.

      Specify the Activity and Workflow IDs:

      ```
      temporal activity pause \
          --activity-id YourActivityId \
          --workflow-id YourWorkflowId
      ```

      To later unpause the activity, see [unpause](#unpause). You may also want to
      [reset](#reset) the activity to unpause it while also starting it from the beginning.
    options:
      - name: activity-id
        short: a
        type: string
        description: The Activity ID to pause. Required.
      - name: identity
        type: string
        description: The identity of the user or client submitting this request.
      - name: reason
        type: string
        description: Reason for pausing the Activity.
    option-sets:
      - workflow-reference

  - name: temporal activity unpause
    summary: Unpause an Activity
    description: |
      Re-schedule a previously-paused Activity for execution.
      Not supported for Standalone Activities.

      If the Activity is not running and is past its retry timeout, it will be
      scheduled immediately. Otherwise, it will be scheduled after its retry
      timeout expires.

      Use `--reset-attempts` to reset the number of previous run attempts to
      zero. For example, if an Activity is near the maximum number of attempts
      N specified in its retry policy, `--reset-attempts` will allow the
      Activity to be retried another N times after unpausing.

      Use `--reset-heartbeat` to reset the Activity's heartbeats.

      Either `--activity-id` (with `--workflow-id`) or `--query` must be specified.

      Specify the Activity and Workflow IDs:

      ```
      temporal activity unpause \
          --activity-id YourActivityId \
          --workflow-id YourWorkflowId
          --reset-attempts
          --reset-heartbeats
      ```

      Activities can be unpaused in bulk via a visibility Query list filter:

      ```
      temporal activity unpause \
          --query 'TemporalPauseInfo IS NOT NULL'
      ```
    options:
      - name: activity-id
        short: a
        type: string
        description: |
          The Activity ID to unpause. Mutually exclusive with `--query`. Requires `--workflow-id` to be specified.
      - name: reset-attempts
        type: bool
        description: Reset the activity attempts.
      - name: reset-heartbeats
        type: bool
        description: Reset the Activity's heartbeats.
      - name: jitter
        type: duration
        description: |
          The activity will start at random a time within the specified duration.
          Can only be used with --query.
    option-sets:
      - single-activity-or-batch

  - name: temporal activity reset
    summary: Reset an Activity
    description: |
      Reset an activity. Not supported for Standalone Activities.
      This restarts the activity as if it were first being
      scheduled. That is, it will reset both the number of attempts and the
      activity timeout, as well as, optionally, the
      [heartbeat details](#reset-heartbeats).

      If the activity may be executing (i.e. it has not yet timed out), the
      reset will take effect the next time it fails, heartbeats, or times out.
      If is waiting for a retry (i.e. has failed or timed out), the reset
      will apply immediately.

      If the activity is already paused, it will be unpaused by default.
      You can specify `keep_paused` to prevent this.

      If the activity is paused and the `keep_paused` flag is not provided,
      it will be unpaused. If the activity is paused and `keep_paused` flag
      is provided - it will stay paused.

      Either `--activity-id` (with `--workflow-id`) or `--query` must be specified.

      ### Resetting activities that heartbeat {#reset-heartbeats}

      Activities that heartbeat will receive a [Canceled failure](/references/failures#cancelled-failure)
      the next time they heartbeat after a reset.

      If, in your Activity, you need to do any cleanup when an Activity is
      reset, handle this error and then re-throw it when you've cleaned up.

      If the `reset_heartbeats` flag is set, the heartbeat details will also be cleared.

      Specify the Activity and Workflow IDs:

      ```
      temporal activity reset \
          --activity-id YourActivityId \
          --workflow-id YourWorkflowId
          --keep-paused
          --reset-heartbeats
      ```

      Activities can be reset in bulk with a visibility query list filter:

      ```
      temporal activity reset \
          --query 'WorkflowType="YourWorkflow"'
      ```
    options:
      - name: activity-id
        short: a
        type: string
        description: The Activity ID to reset. Mutually exclusive with `--query`. Requires `--workflow-id` to be specified.
      - name: keep-paused
        type: bool
        description: If the activity was paused, it will stay paused.
      - name: reset-attempts
        type: bool
        description: Reset the activity attempts.
      - name: reset-heartbeats
        type: bool
        description: Reset the Activity's heartbeats.
      - name: jitter
        type: duration
        description: |
          The activity will reset at random a time within the specified duration.
          Can only be used with --query.
      - name: restore-original-options
        type: bool
        description: |
          Restore the original options of the activity.
    option-sets:
      - single-activity-or-batch

  - name: temporal activity result
    summary: Wait for and output the result of a Standalone Activity (Experimental)
    description: |
      Wait for a Standalone Activity to complete and output the
      result.

      ```
      temporal activity result \
          --activity-id YourActivityId
      ```
    option-sets:
      - activity-reference

  - name: temporal activity start
    summary: Start a new Standalone Activity (Experimental)
    description: |
      Start a new Standalone Activity. Outputs the Activity ID and
      Run ID.

      ```
      temporal activity start \
          --activity-id YourActivityId \
          --type YourActivity \
          --task-queue YourTaskQueue \
          --start-to-close-timeout 5m \
          --input '{"some-key": "some-value"}'
      ```
    option-sets:
      - activity-start
      - payload-input

  - name: temporal activity terminate
    summary: Forcefully end a Standalone Activity (Experimental)
    description: |
      Terminate a Standalone Activity.

      ```
      temporal activity terminate \
          --activity-id YourActivityId \
          --reason YourReason
      ```

      Activity code cannot see or respond to terminations.
    option-sets:
      - activity-reference
    options:
      - name: reason
        type: string
        description: |
          Reason for termination.
          Defaults to a message with the current user's name.

  - name: temporal batch
    summary: Manage running batch jobs
    description: |
      List or terminate running batch jobs.

      A batch job executes a command on multiple Workflow Executions at once. Create
      batch jobs by passing `--query` to commands that support it. For example, to
      create a batch job to cancel a set of Workflow Executions:

      ```
      temporal workflow cancel \
        --query 'ExecutionStatus = "Running" AND WorkflowType="YourWorkflow"' \
        --reason "Testing"
      ```

      Query Quick Reference:

      ```
      +----------------------------------------------------------------------------+
      | Composition:                                                               |
      | - Data types: String literals with single or double quotes,                |
      |   Numbers (integer and floating point), Booleans                           |
      | - Comparison: '=', '!=', '>', '>=', '<', '<='                              |
      | - Expressions/Operators:  'IN array', 'BETWEEN value AND value',           |
      |   'STARTS_WITH string', 'IS NULL', 'IS NOT NULL', 'expr AND expr',         |
      |   'expr OR expr', '( expr )'                                               |
      | - Array: '( comma-separated-values )'                                      |
      |                                                                            |
      | Please note:                                                               |
      | - Wrap attributes with backticks if it contains characters not in          |
      |   [a-zA-Z0-9].                                                             |
      | - STARTS_WITH is only available for Keyword search attributes.             |
      +----------------------------------------------------------------------------+
      ```

      Visit https://docs.temporal.io/visibility to read more about Search Attributes
      and Query creation.
    option-sets:
      - client
    docs:
      description-header: >-
        Use Temporal CLI to manage multiple Workflow Executions with Batch
        Jobs that can Cancel, Signal, or Terminate Workflows. Filter and monitor
        Batch Jobs effectively.
      keywords:
        - batch
        - batch describe
        - batch list
        - batch terminate
        - cli reference
        - cli-feature
        - command-line-interface-cli
        - temporal cli
      tags:
        - Temporal CLI

  - name: temporal batch describe
    summary: Show batch job progress
    description: |
      Show the progress of an ongoing batch job. Pass a valid job ID to display its
      information:

      ```
      temporal batch describe \
          --job-id YourJobId
      ```
    options:
      - name: job-id
        type: string
        description: Batch job ID.
        required: true

  - name: temporal batch list
    summary: List all batch jobs
    description: |
      Return a list of batch jobs on the Service or within a single Namespace. For
      example, list the batch jobs for "YourNamespace":

      ```
      temporal batch list \
          --namespace YourNamespace
      ```
    options:
      - name: limit
        type: int
        description: Maximum number of batch jobs to display.

  - name: temporal batch terminate
    summary: Forcefully end a batch job
    description: |
      Terminate a batch job with the provided job ID. You must provide a reason for
      the termination. The Service stores this explanation as metadata for the
      termination event for later reference:

      ```
      temporal batch terminate \
          --job-id YourJobId \
          --reason YourTerminationReason
      ```
    options:
      - name: job-id
        type: string
        description: Job ID to terminate.
        required: true
      - name: reason
        type: string
        description: Reason for terminating the batch job.
        required: true

  - name: temporal config
    summary: Manage config files (EXPERIMENTAL)
    description: |
      Config files are TOML files that contain profiles, with each profile
      containing configuration for connecting to Temporal.

      ```
      temporal config set \
          --prop address \
          --value us-west-2.aws.api.temporal.io:7233
      ```

      The default config file path is `$CONFIG_PATH/temporalio/temporal.toml` where
      `$CONFIG_PATH` is defined as `$HOME/.config` on Unix,
      `$HOME/Library/Application Support` on macOS, and `%AppData%` on Windows.
      This can be overridden with the `TEMPORAL_CONFIG_FILE` environment
      variable or `--config-file`.

      The default profile is `default`. This can be overridden with the
      `TEMPORAL_PROFILE` environment variable or `--profile`.
    docs:
      description-header: >-
        Temporal CLI 'config' commands allow the getting, setting, deleting, and
        listing of configuration properties for connecting to Temporal.
      keywords:
        - cli reference
        - command-line-interface-cli
        - configuration
        - config
        - config delete
        - config get
        - config list
        - config set
        - environment
        - temporal cli
      tags:
        - Temporal CLI

  - name: temporal config delete
    summary: |
      Delete a config file property (EXPERIMENTAL)
    description: |
      Remove a property within a profile.

      ```
      temporal config delete \
          --prop tls.client_cert_path
      ```
    options:
      - name: prop
        short: p
        type: string
        description: |
          Specific property to delete. If unset, deletes entire profile.
        required: true

  - name: temporal config delete-profile
    summary: |
      Delete an entire config profile (EXPERIMENTAL)
    description: |
      Remove a full profile entirely. The `--profile` must be set explicitly.

      ```
      temporal config delete-profile \
          --profile my-profile
      ```

  - name: temporal config get
    summary: Show config file properties (EXPERIMENTAL)
    description: |
      Display specific properties or the entire profile.

      ```
      temporal config get \
          --prop address
      ```

      or

      ```
      temporal config get
      ```
    options:
      - name: prop
        short: p
        type: string
        description: Specific property to get.

  - name: temporal config list
    summary: Show config file profiles (EXPERIMENTAL)
    description: |
      List profile names in the config file.

      ```
      temporal config list
      ```

  - name: temporal config set
    summary: Set config file properties (EXPERIMENTAL)
    description: |
      Assign a value to a property and store it in the config file:

      ```
      temporal config set \
          --prop address \
          --value us-west-2.aws.api.temporal.io:7233
      ```
    options:
      - name: prop
        short: p
        type: string
        description: Property name.
        required: true
      - name: value
        short: v
        type: string
        description: Property value.
        required: true

  - name: temporal worker
    summary: Read or update Worker state
    description: |
      Modify or read state associated with a Worker, for example,
      using Worker Deployments commands:

      ```
      temporal worker deployment
      ```
    option-sets:
      - client
    docs:
      description-header: >-
        Learn how to read or modify state associated with a Worker,
        such as Worker Deployments.
      keywords:
        - worker
        - worker deployment
        - worker list
        - worker describe
      tags:
        - Temporal CLI

  - name: temporal worker deployment
    summary: Describe, list, and operate on Worker Deployments and Versions
    description: |
      Deployment commands perform operations on Worker Deployments:

      ```
      temporal worker deployment [command] [options]
      ```

      For example:

      ```
      temporal worker deployment list
      ```

      Lists the Deployments in the client's namespace.

      Arguments can be Worker Deployment Versions associated with
      a Deployment, specified using the Deployment name and Build ID.

      For example:

      ```
      temporal worker deployment set-current-version \
               --deployment-name YourDeploymentName --build-id YourBuildID
      ```

      Sets the current Deployment Version for a given Deployment.

    docs:
      description-header: >-
        Temporal Deployment commands enable operations on Worker Deployments
        that simplify versioning and management of workers,
        such as describe, list, delete, and also operations that refer to Worker
        Deployment Versions within them, such as describe-version,
        delete-version, set-current-version, or set-ramping-version.
      keywords:
        - worker deployment
        - worker deployment create
        - worker deployment describe
        - worker deployment list
        - worker deployment delete
        - worker deployment create-version
        - worker deployment describe-version
        - worker deployment set-current-version
        - worker deployment set-ramping-version
        - worker deployment delete-version
        - worker deployment update-version-metadata
        - worker deployment manager-identity

  - name: temporal worker deployment create
    summary: Create a new Worker Deployment
    description: |
      Create a new Worker Deployment:

      ```
      temporal worker deployment create [options]
      ```

      Worker Deployments are lazily created the first time a Worker polls the
      Temporal Server and specifies a VersionOverride. However, if you need to
      pre-define a compute configuration (for instance to set up a serverless
      Worker), you need to call `temporal worker deployment create-version` and
      pass in the name of the Worker Deployment. The `temporal worker
      deployment create` command allows you to pre-define a Worker Deployment
      so that calls to `temporal worker deployment create-version` will
      succeed.
      
      If a Worker Deployment with the supplied name already exists, this
      command will return an error.
      
      Note: This is an experimental feature and may change in the future.
    option-sets:
      - deployment-name

  - name: temporal worker deployment describe
    summary: Show properties of a Worker Deployment
    description: |
      Describe properties of a Worker Deployment, such as the versions
      associated with it, routing information of new or existing tasks
      executed by this deployment, or its creation time.

      ```
      temporal worker deployment describe [options]
      ```

      For example, to describe a deployment `YourDeploymentName` in the default
      namespace:

      ```
      temporal worker deployment describe \
          --name YourDeploymentName
      ```
    option-sets:
      - deployment-name

  - name: temporal worker deployment delete
    summary: Delete a Worker Deployment
    description: |
      Remove a Worker Deployment given its Deployment Name.
      A Deployment can only be deleted if it has no Version in it.

      ```
      temporal worker deployment delete [options]
      ```

      For example, setting the user identity that removed the deployment:

      ```
      temporal worker deployment delete \
          --name YourDeploymentName \
          --identity YourIdentity

      ```
    option-sets:
      - deployment-name

  - name: temporal worker deployment list
    summary: Enumerate Worker Deployments in the client's namespace
    description: |
      List existing Worker Deployments in the client's namespace.

      ```
      temporal worker deployment list [options]
      ```

      For example, listing Deployments in YourDeploymentNamespace:

      ```
      temporal worker deployment list \
          --namespace YourDeploymentNamespace
      ```

  - name: temporal worker deployment create-version
    summary: Create a new Worker Deployment Version
    description: |

      Create a new Worker Deployment Version:

      ```
      temporal worker deployment create-version [options]
      ```

      Configure a Worker Deployment Version's compute configuration as needed.
      For example, pass compute provider information for an AWS Lambda function
      that spawns a Worker in the Worker Deployment:

      ```
      temporal worker deployment create-version \
          --namespace YourNamespaceName \
          --deployment-name YourDeploymentName \
          --build-id YourBuildID \
          --aws-lambda-function-arn LambdaFunctionARN \
          --aws-lambda-assume-role-arn LambdaAssumeRoleARN \
          --aws-lambda-assume-role-external-id LambdaAssumeRoleExternalID
      ```
      
      If a Worker Deployment Version with the supplied BuildID already exists,
      this command will return an error.

      Note: This is an experimental feature and may change in the future.
    option-sets:
      - deployment-version
    options:
      - name: aws-lambda-function-arn
        type: string
        description: |
          Qualified (contains version suffix) or unqualified AWS Lambda
          function ARN to invoke when there are no active pollers for task
          queue targets in the Worker Deployment.
      - name: aws-lambda-assume-role-arn
        type: string
        description: |
          AWS IAM role ARN that the Temporal server will assume when invoking
          the Lambda function that spawns a new Worker in this Worker
          Deployment Version. Required when --aws-lambda-function-arn is
          specified.
      - name: aws-lambda-assume-role-external-id
        type: string
        description: |
          Temporal server will enforce that the AWS IAM trust policy associated
          with the AWS IAM role specified in --aws-lambda-assume-role-arn has
          an aws:ExternalId condition that matches the supplied value. Required
          when --aws-lambda-function-arn is specified.

  - name: temporal worker deployment describe-version
    summary: Show properties of a Worker Deployment Version
    description: |
      Describe properties of a Worker Deployment Version, such as the task
      queues polled by workers in this Deployment Version, or drainage
      information required to safely decommission workers, or user-provided
      metadata, or its creation/modification time.

      ```
      temporal worker deployment describe-version [options]
      ```

      For example, to describe a deployment version  in a deployment
      `YourDeploymentName`, with Build ID `YourBuildID`, and in the default
      namespace:

      ```
      temporal worker deployment describe-version \
          --deployment-name YourDeploymentName --build-id YourBuildID
      ```
    option-sets:
      - deployment-version
    options:
      - name: report-task-queue-stats
        type: bool
        description: Report stats for task queues that are present in this version.

  - name: temporal worker deployment delete-version
    summary: Delete a Worker Deployment Version
    description: |
      Remove a Worker Deployment Version given its fully-qualified identifier.
      This is rarely needed during normal operation
      since unused Versions are eventually garbage collected.
      The client can delete a Version only when all of the following conditions
      are met:
        - It is not the Current or Ramping Version for this Deployment.
        - It has no active pollers, i.e., none of the task queues in the
        Version have pollers.
        - It is not draining. This requirement can be ignored with the option
      `--skip-drainage`.
      ```
      temporal worker deployment delete-version [options]
      ```

      For example, skipping the drainage restriction:

      ```
      temporal worker deployment delete-version \
          --deployment-name YourDeploymentName --build-id YourBuildID \
          --skip-drainage
      ```
    option-sets:
      - deployment-version
    options:
      - name: skip-drainage
        type: bool
        description: Ignore the deletion requirement of not draining.

  - name: temporal worker deployment set-current-version
    summary: Make a Worker Deployment Version Current for a Deployment
    description: |
      Set the Current Version for a Deployment.
      When a Version is current, Workers of that Deployment Version will receive
      tasks from new Workflows, and from existing AutoUpgrade Workflows that
      are running on this Deployment.

      If not all the expected Task Queues are being polled by Workers in the
      new Version the request will fail. To override this protection use
      `--ignore-missing-task-queues`. Note that this would ignore task queues
      in a deployment that are not yet discovered, leading to inconsistent task
      queue configuration.

      ```
      temporal worker deployment set-current-version [options]
      ```

      For example, to set the Current Version of a deployment
      `YourDeploymentName`, with a version with Build ID `YourBuildID`, and
      in the default namespace:

      ```
      temporal worker deployment set-current-version \
          --deployment-name YourDeploymentName --build-id YourBuildID
      ```

      The target of set-current-version can also be unversioned workers:

      ```
      temporal worker deployment set-current-version \
          --deployment-name YourDeploymentName --unversioned
      ```
    option-sets:
      - deployment-version-or-unversioned
    options:
      - name: ignore-missing-task-queues
        type: bool
        description: Override protection to accidentally remove task queues.
      - name: allow-no-pollers
        type: bool
        description: Override protection and set version as current even if it has no pollers.
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm set Current Version.

  - name: temporal worker deployment set-ramping-version
    summary: Change Version Ramping settings for a Worker Deployment
    description: |
      Set the Ramping Version and Percentage for a Deployment.

      The Ramping Version can be set using deployment name and build ID,
      or set to unversioned workers using the --unversioned flag.

      The Ramping Percentage is a float with values in the range [0, 100].
      A value of 100 does not make the Ramping Version Current, use
      `set-current-version` instead.

      To remove a Ramping Version use the flag `--delete`.

      If not all the expected Task Queues are being polled by Workers in the
      new Ramping Version the request will fail. To override this protection use
      `--ignore-missing-task-queues`. Note that this would ignore task queues
      in a deployment that are not yet discovered, leading to inconsistent task
      queue configuration.

      ```
      temporal worker deployment set-ramping-version [options]
      ```

      For example, to set the Ramping Version of a deployment
      `YourDeploymentName`, with a version with Build ID `YourBuildID`, with
      10 percent of tasks redirected to this version, and
      using the default namespace:

      ```
      temporal worker deployment set-ramping-version \
          --deployment-name YourDeploymentName --build-id YourBuildID \
          --percentage 10.0
      ```

      And to remove that ramping:
      ```
      temporal worker deployment set-ramping-version \
          --deployment-name YourDeploymentName --build-id YourBuildID \
          --delete
      ```
    option-sets:
      - deployment-version-or-unversioned
    options:
      - name: percentage
        type: float
        description: |
          Percentage of tasks redirected to the Ramping Version.
          Valid range [0,100].
      - name: delete
        type: bool
        description: Delete the Ramping Version.
      - name: ignore-missing-task-queues
        type: bool
        description: Override protection to accidentally remove task queues.
      - name: allow-no-pollers
        type: bool
        description: Override protection and set version as ramping even if it has no pollers.
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm set Ramping Version.

  - name: temporal worker deployment update-version-metadata
    summary: Change user-provided metadata for a Version
    description: |
      Update metadata associated with a Worker Deployment Version.

      For example:

      ```
       temporal worker deployment update-version-metadata \
          --deployment-name YourDeploymentName --build-id YourBuildID \
          --metadata bar=1 \
          --metadata foo=true
      ```

      The current metadata is also returned with `describe-version`:
      ```
       temporal worker deployment describe-version \
          --deployment-name YourDeploymentName --build-id YourBuildID \
      ```
    option-sets:
      - deployment-version
    options:
      - name: metadata
        type: string[]
        description: |
          Set deployment metadata using `KEY="VALUE"` pairs.
          Keys must be identifiers, and values must be JSON values.
          For example: `YourKey={"your": "value"}`
          Can be passed multiple times.
      - name: remove-entries
        type: string[]
        description: |
          Keys of entries to be deleted from metadata.
          Can be passed multiple times.

  - name: temporal worker deployment manager-identity
    summary: Manager Identity commands change the `ManagerIdentity` of a Worker Deployment
    description: |
      Manager Identity commands change the `ManagerIdentity` of a Worker Deployment:

      ```
      temporal worker deployment manager-identity [command] [options]
      ```

      When present, `ManagerIdentity` is the identity of the user that has the
      exclusive right to make changes to this Worker Deployment. Empty by default.
      When set, users whose identity does not match the `ManagerIdentity` will not
      be able to change the Worker Deployment.

      This is especially useful in environments where multiple users (such as CLI
      users and automated controllers) may interact with the same Worker Deployment.
      `ManagerIdentity` allows different users to communicate with one another about
      who is expected to make changes to the Worker Deployment.

      The current Manager Identity is returned with `describe`:
      ```
       temporal worker deployment describe \
          --deployment-name YourDeploymentName
      ```

    docs:
      description-header: >-
        Temporal Deployment Manager Identity commands enable set and unset
        operations on the manager identity field of Worker Deployments.
      keywords:
        - worker deployment manager-identity set
        - worker deployment manager-identity unset

  - name: temporal worker deployment manager-identity set
    summary: Set the Manager Identity of a Worker Deployment
    description: |
      Set the `ManagerIdentity` of a Worker Deployment given its Deployment Name.

      When present, `ManagerIdentity` is the identity of the user that has the
      exclusive right to make changes to this Worker Deployment. Empty by default.
      When set, users whose identity does not match the `ManagerIdentity` will not
      be able to change the Worker Deployment.

      This is especially useful in environments where multiple users (such as CLI
      users and automated controllers) may interact with the same Worker Deployment.
      `ManagerIdentity` allows different users to communicate with one another about
      who is expected to make changes to the Worker Deployment.

      ```
      temporal worker deployment manager-identity set [options]
      ```

      For example:

      ```
      temporal worker deployment manager-identity set \
         --deployment-name DeploymentName \
         --self \
         --identity YourUserIdentity # optional, populated by CLI if not provided
      ```

      Sets the Manager Identity of the Deployment to the identity of the user making
      this request. If you don't specifically pass an identity field, the CLI will
      generate your identity for you.

      For example:
      ```
      temporal worker deployment manager-identity set \
         --deployment-name DeploymentName \
         --manager-identity NewManagerIdentity
      ```

      Sets the Manager Identity of the Deployment to any string.

    options:
      - name: manager-identity
        type: string
        description: New Manager Identity. Required unless --self is specified.
      - name: self
        type: bool
        description: Set Manager Identity to the identity of the user submitting this request. Required unless --manager-identity is specified.
      - name: deployment-name
        type: string
        description: Name for a Worker Deployment. Required.
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm set Manager Identity.

  - name: temporal worker deployment manager-identity unset
    summary: Unset the Manager Identity of a Worker Deployment
    description: |
      Unset the `ManagerIdentity` of a Worker Deployment given its Deployment Name.

      When present, `ManagerIdentity` is the identity of the user that has the
      exclusive right to make changes to this Worker Deployment. Empty by default.
      When set, users whose identity does not match the `ManagerIdentity` will not
      be able to change the Worker Deployment.

      This is especially useful in environments where multiple users (such as CLI
      users and automated controllers) may interact with the same Worker Deployment.
      `ManagerIdentity` allows different users to communicate with one another about
      who is expected to make changes to the Worker Deployment.

      ```
      temporal worker deployment manager-identity unset [options]
      ```

      For example:

      ```
      temporal worker deployment manager-identity unset \
         --deployment-name YourDeploymentName
      ```

      Clears the Manager Identity field for a given Deployment.

    options:
      - name: deployment-name
        type: string
        description: Name for a Worker Deployment. Required.
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm unset Manager Identity.

  - name: temporal worker list
    summary: List worker status information in a specific namespace (EXPERIMENTAL)
    description: |
      Get a list of workers to the specified namespace.

      ```
      temporal worker list --namespace YourNamespace --query 'TaskQueue="YourTaskQueue"'
      ```
    options:
      - name: query
        short: q
        type: string
        description: Content for an SQL-like `QUERY` List Filter.
      - name: limit
        type: int
        description: Maximum number of workers to display.

  - name: temporal worker describe
    summary: Returns information about a specific worker (EXPERIMENTAL)
    description: |
      Look up information of a specific worker.

      ```
      temporal worker describe --namespace YourNamespace --worker-instance-key YourKey
      ```
    options:
      - name: worker-instance-key
        type: string
        description: Worker instance key to describe.
        required: true

  - name: temporal env
    summary: Manage environments
    description: |
      Environments manage key-value presets, auto-configuring Temporal CLI options
      for you. You can set up distinct environments like "dev" and "prod" for
      convenience:

      ```
      temporal env set \
          --env prod \
          --key address \
          --value production.f45a2.tmprl.cloud:7233
      ```

      Each environment is isolated. Changes to "prod" presets won't affect "dev".

      For easiest use, set a `TEMPORAL_ENV` environment variable in your shell. The
      Temporal CLI checks for an `--env` option first, then checks for the
      `TEMPORAL_ENV` environment variable. If neither is set, the CLI uses the
      "default" environment.
    # TODO(cretz): Deprecate when `config` GA
    # deprecated: Use `config` subcommands instead.
    docs:
      description-header: >-
        Temporal CLI 'env' commands allow the configuration, setting, deleting,
        and listing of environmental properties, making it easy to manage Temporal
        Server instances.
      keywords:
        - cli reference
        - command-line-interface-cli
        - configuration
        - env
        - env delete
        - env get
        - env list
        - env set
        - environment
        - temporal cli
      tags:
        - Temporal CLI

  - name: temporal env delete
    summary: Delete an environment or environment property
    description: |
      Remove a presets environment entirely _or_ remove a key-value pair within an
      environment. If you don't specify an environment (with `--env` or by setting
      the `TEMPORAL_ENV` variable), this command updates the "default" environment:

      ```
      temporal env delete \
          --env YourEnvironment
      ```

      or

      ```
      temporal env delete \
          --env prod \
          --key tls-key-path
      ```
    # TODO(cretz): Deprecate when `config` GA
    # deprecated: Use `config` subcommands instead.
    maximum-args: 1
    options:
      - name: key
        short: k
        type: string
        description: Property name.

  - name: temporal env get
    summary: Show environment properties
    description: |
      List the properties for a given environment:

      ```
      temporal env get \
          --env YourEnvironment
      ```

      Print a single property:

      ```
      temporal env get \
          --env YourEnvironment \
          --key YourPropertyKey
      ```

      If you don't specify an environment (with `--env` or by setting the
      `TEMPORAL_ENV` variable), this command lists properties of the "default"
      environment.
    # TODO(cretz): Deprecate when `config` GA
    # deprecated: Use `config` subcommands instead.
    maximum-args: 1
    options:
      - name: key
        type: string
        short: k
        description: Property name.

  - name: temporal env list
    summary: Show environment names
    description: |
      List the environments you have set up on your local computer. Environments are
      stored in "$HOME/.config/temporalio/temporal.yaml".
    # TODO(cretz): Deprecate when `config` GA
    # deprecated: Use `config` subcommands instead.
    ignores-missing-env: true

  - name: temporal env set
    summary: Set environment properties
    description: |
      Assign a value to a property key and store it to an environment:

      ```
      temporal env set \
          --env environment \
          --key property \
          --value value
      ```

      If you don't specify an environment (with `--env` or by setting the
      `TEMPORAL_ENV` variable), this command sets properties in the "default"
      environment.

      Storing keys with CLI option names lets the CLI automatically set those
      options for you. This reduces effort and helps avoid typos when issuing
      commands.
    # TODO(cretz): Deprecate when `config` GA
    # deprecated: Use `config` subcommands instead.
    maximum-args: 2
    ignores-missing-env: true
    options:
      - name: key
        short: k
        type: string
        description: Property name (required).
        # required: true
      - name: value
        short: v
        type: string
        description: Property value (required).
        # required: true

  - name: temporal operator
    summary: Manage Temporal deployments
    description: |
      Operator commands manage and fetch information about Namespaces, Search
      Attributes, Nexus Endpoints, and Temporal Services:

      ```
      temporal operator [command] [subcommand] [options]
      ```

      For example, to show information about the Temporal Service at the default
      address (localhost):

      ```
      temporal operator cluster describe
      ```
    option-sets:
      - client
    docs:
      description-header: >-
        Operator commands in Temporal allow actions on Namespaces, Search
        Attributes, Clusters and Nexus Endpoints using specific subcommands.
        Execute with "temporal operator [command] [subcommand] [options]".
      keywords:
        - cli reference
        - cluster
        - cluster health
        - cluster list
        - cluster remove
        - cluster upsert
        - command-line-interface-cli
        - describe
        - namespace
        - namespace create
        - namespace delete
        - namespace describe
        - namespace list
        - nexus
        - nexus endpoint
        - nexus endpoint create
        - nexus endpoint delete
        - nexus endpoint get
        - nexus endpoint list
        - nexus endpoint update
        - operator
        - search attribute
        - search attribute create
        - search attribute list
        - search attribute remove
        - system
        - temporal cli
        - update
      tags:
        - Temporal CLI

  - name: temporal operator cluster
    summary: Manage a Temporal Cluster
    description: |
      Perform operator actions on Temporal Services (also known as Clusters).

      ```
      temporal operator cluster [subcommand] [options]
      ```

      For example to check Service/Cluster health:

      ```
      temporal operator cluster health
      ```

  - name: temporal operator cluster describe
    summary: Show Temporal Cluster information
    description: |
      View information about a Temporal Cluster (Service), including Cluster Name,
      persistence store, and visibility store. Add `--detail` for additional info:

      ```
      temporal operator cluster describe [--detail]
      ```
    options:
      - name: detail
        type: bool
        description: Show history shard count and Cluster/Service version information.

  - name: temporal operator cluster health
    summary: Check Temporal Service health
    description: |
      View information about the health of a Temporal Service:

      ```
      temporal operator cluster health
      ```

  - name: temporal operator cluster list
    summary: Show Temporal Clusters
    description: |
      Print a list of remote Temporal Clusters (Services) registered to the local
      Service. Report details include the Cluster's name, ID, address, History Shard
      count, Failover version, and availability:

      ```
      temporal operator cluster list [--limit max-count]
      ```
    options:
      - name: limit
        type: int
        description: Maximum number of Clusters to display.

  - name: temporal operator cluster remove
    summary: Remove a Temporal Cluster
    description: |
      Remove a registered remote Temporal Cluster (Service) from the local Service.

      ```
      temporal operator cluster remove \
          --name YourClusterName
      ```
    options:
      - name: name
        type: string
        description: Cluster/Service name.
        required: true

  - name: temporal operator cluster system
    summary: Show Temporal Cluster info
    description: |
      Show Temporal Server information for Temporal Clusters (Service): Server
      version, scheduling support, and more. This information helps diagnose
      problems with the Temporal Server.

      The command defaults to the local Service. Otherwise, use the
      `--frontend-address` option to specify a Cluster (Service) endpoint:

      ```
      temporal operator cluster system \
          --frontend-address "YourRemoteEndpoint:YourRemotePort"
      ```

  - name: temporal operator cluster upsert
    summary: Add/update a Temporal Cluster
    description: |
      Add, remove, or update a registered ("remote") Temporal Cluster (Service).

      ```
      temporal operator cluster upsert [options]
      ```

      For example:

      ```
      temporal operator cluster upsert \
          --frontend-address "YourRemoteEndpoint:YourRemotePort"
          --enable-connection false
      ```
    options:
      - name: frontend-address
        type: string
        description: Remote endpoint.
        required: true
      - name: enable-connection
        type: bool
        description: Set the connection to "enabled".
      - name: enable-replication
        type: bool
        description: Set the replication to "enabled".

  - name: temporal operator namespace
    summary: Namespace operations
    description: |
      Manage Temporal Cluster (Service) Namespaces:

      ```
      temporal operator namespace [command] [command options]
      ```

      For example:

      ```
      temporal operator namespace create \
          --namespace YourNewNamespaceName
      ```

  - name: temporal operator namespace create
    summary: Register a new Namespace
    description: |
      Create a new Namespace on the Temporal Service:

      ```
      temporal operator namespace create \
          --namespace YourNewNamespaceName \
          [options]
      ```

      Create a Namespace with multi-region data replication:

      ```
      temporal operator namespace create \
          --global \
          --namespace YourNewNamespaceName
      ```

      Configure settings like retention and Visibility Archival State as needed.
      For example, the Visibility Archive can be set on a separate URI:

      ```
      temporal operator namespace create \
          --retention 5d \
          --visibility-archival-state enabled \
          --visibility-uri YourURI \
          --namespace YourNewNamespaceName
      ```

      Note: URI values for archival states can't be changed once enabled.
    maximum-args: 1
    options:
      - name: active-cluster
        type: string
        description: Active Cluster (Service) name.
      - name: cluster
        type: string[]
        description: |
          Cluster (Service) names for Namespace creation.
          Can be passed multiple times.
      - name: data
        type: string[]
        description: |
          Namespace data as `KEY=VALUE` pairs.
          Keys must be identifiers, and values must be JSON values.
          For example: `YourKey={"your": "value"}`
          Can be passed multiple times.
      - name: description
        type: string
        description: Namespace description.
      - name: email
        type: string
        description: Owner email.
      - name: global
        type: bool
        description: Enable multi-region data replication.
      - name: history-archival-state
        type: string-enum
        description: History archival state.
        enum-values:
          - disabled
          - enabled
        default: disabled
      - name: history-uri
        type: string
        description: |
          Archive history to this `URI`.
          Once enabled, can't be changed.
      - name: retention
        type: duration
        description: Time to preserve closed Workflows before deletion.
        default: 72h
      - name: visibility-archival-state
        type: string-enum
        description: Visibility archival state.
        enum-values:
          - disabled
          - enabled
        default: disabled
      - name: visibility-uri
        type: string
        description: |
          Archive visibility data to this `URI`.
          Once enabled, can't be changed.

  - name: temporal operator namespace delete
    summary: Delete a Namespace
    description: |
      Removes a Namespace from the Service.

      ```
      temporal operator namespace delete [options]
      ```

      For example:

      ```
      temporal operator namespace delete \
          --namespace YourNamespaceName
      ```
    maximum-args: 1
    options:
      - name: yes
        short: y
        type: bool
        description: Request confirmation before deletion.

  - name: temporal operator namespace describe
    summary: Describe a Namespace
    description: |
      Provide long-form information about a Namespace identified by its ID or name:

      ```
      temporal operator namespace describe \
          --namespace-id YourNamespaceId
      ```

      or

      ```
      temporal operator namespace describe \
          --namespace YourNamespaceName
      ```
    maximum-args: 1
    options:
      - name: namespace-id
        type: string
        description: Namespace ID.

  - name: temporal operator namespace list
    summary: List Namespaces
    description: |
      Display a detailed listing for all Namespaces on the Service:

      ```
      temporal operator namespace list
      ```

  - name: temporal operator namespace update
    summary: Update a Namespace
    description: |
      Update a Namespace using properties you specify.

      ```
      temporal operator namespace update [options]
      ```

      Assign a Namespace's active Cluster (Service):

      ```
      temporal operator namespace update \
          --namespace YourNamespaceName \
          --active-cluster NewActiveCluster
      ```

      Promote a Namespace for multi-region data replication:

      ```
      temporal operator namespace update \
          --namespace YourNamespaceName \
          --promote-global
      ```

      You may update archives that were previously enabled or disabled. Note: URI
      values for archival states can't be changed once enabled.

      ```
      temporal operator namespace update \
          --namespace YourNamespaceName \
          --history-archival-state enabled \
          --visibility-archival-state disabled
      ```
    maximum-args: 1
    options:
      - name: active-cluster
        type: string
        description: Active Cluster (Service) name.
      - name: cluster
        type: string[]
        description: Cluster (Service) names.
      - name: data
        type: string[]
        description: |
          Namespace data as `KEY=VALUE` pairs.
          Keys must be identifiers, and values must be JSON values.
          For example: `YourKey={"your": "value"}`
          Can be passed multiple times.
      - name: description
        type: string
        description: Namespace description.
      - name: email
        type: string
        description: Owner email.
      - name: promote-global
        type: bool
        description: Enable multi-region data replication.
      - name: history-archival-state
        type: string-enum
        description: History archival state.
        enum-values:
          - disabled
          - enabled
      - name: history-uri
        type: string
        description: |
          Archive history to this `URI`.
          Once enabled, can't be changed.
      - name: replication-state
        type: string-enum
        description: Replication state.
        enum-values:
          - normal
          - handover
      - name: retention
        type: duration
        description: Length of time a closed Workflow is preserved before deletion.
      - name: visibility-archival-state
        type: string-enum
        description: Visibility archival state.
        enum-values:
          - disabled
          - enabled
      - name: visibility-uri
        type: string
        description: |
          Archive visibility data to this `URI`.
          Once enabled, can't be changed.

  - name: temporal operator nexus
    summary: Commands for managing Nexus resources
    description: |
      These commands manage Nexus resources.

      Nexus commands follow this syntax:

      ```
      temporal operator nexus [command] [subcommand] [options]
      ```

  - name: temporal operator nexus endpoint
    summary: Commands for managing Nexus Endpoints
    description: |
      These commands manage Nexus Endpoints.

      Nexus Endpoint commands follow this syntax:

      ```
      temporal operator nexus endpoint [command] [options]
      ```

  - name: temporal operator nexus endpoint create
    summary: Create a Nexus Endpoint
    description: |
      Create a Nexus Endpoint on the Server.

      A Nexus Endpoint name is used in Workflow code to invoke Nexus Operations.
      The endpoint target may either be a Worker, in which case
      `--target-namespace` and `--target-task-queue` must both be provided, or
      an external URL, in which case `--target-url` must be provided.

      This command will fail if an Endpoint with the same name is already
      registered.

      ```
      temporal operator nexus endpoint create \
        --name your-endpoint \
        --target-namespace your-namespace \
        --target-task-queue your-task-queue \
        --description-file DESCRIPTION.md
      ```
    option-sets:
      - nexus-endpoint-identity
      - nexus-endpoint-config
  - name: temporal operator nexus endpoint delete
    summary: Delete a Nexus Endpoint
    description: |
      Delete a Nexus Endpoint from the Server.

      ```
      temporal operator nexus endpoint delete --name your-endpoint
      ```
    option-sets:
      - nexus-endpoint-identity

  - name: temporal operator nexus endpoint get
    summary: Get a Nexus Endpoint by name (EXPERIMENTAL)
    description: |
      Get a Nexus Endpoint by name from the Server.

      ```
      temporal operator nexus endpoint get --name your-endpoint
      ```
    option-sets:
      - nexus-endpoint-identity

  - name: temporal operator nexus endpoint list
    summary: List Nexus Endpoints
    description: |
      List all Nexus Endpoints on the Server.

      ```
      temporal operator nexus endpoint list
      ```

  - name: temporal operator nexus endpoint update
    summary: Update an existing Nexus Endpoint
    description: |
      Update an existing Nexus Endpoint on the Server.

      A Nexus Endpoint name is used in Workflow code to invoke Nexus Operations.
      The Endpoint target may either be a Worker, in which case
      `--target-namespace` and `--target-task-queue` must both be provided, or
      an external URL, in which case `--target-url` must be provided.

      The Endpoint is patched; existing fields for which flags are not provided
      are left as they were.

      Update only the target task queue:

      ```
      temporal operator nexus endpoint update \
        --name your-endpoint \
        --target-task-queue your-other-queue
      ```

      Update only the description:

      ```
      temporal operator nexus endpoint update \
        --name your-endpoint \
        --description-file DESCRIPTION.md
      ```
    option-sets:
      - nexus-endpoint-identity
      - nexus-endpoint-config
    options:
      - name: unset-description
        type: bool
        description: Unset the description.

  - name: temporal operator search-attribute
    summary: Search Attribute operations
    description: |
      Create, list, or remove Search Attributes fields stored in a Workflow
      Execution's metadata:

      ```
      temporal operator search-attribute create \
          --name YourAttributeName \
          --type Keyword
      ```

      Supported types include: Text, Keyword, Int, Double, Bool, Datetime, and
      KeywordList.

      If you wish to delete a Search Attribute, please contact support
      at https://support.temporal.io.

  - name: temporal operator search-attribute create
    summary: Add custom Search Attributes
    description: |
      Add one or more custom Search Attributes:

      ```
      temporal operator search-attribute create \
          --name YourAttributeName \
          --type Keyword
      ```
    options:
      - name: name
        type: string[]
        description: Search Attribute name.
        required: true
      - name: type
        type: string-enum[]
        description: Search Attribute type.
        enum-values:
          - Text
          - Keyword
          - Int
          - Double
          - Bool
          - Datetime
          - KeywordList
        required: true

  - name: temporal operator search-attribute list
    summary: List Search Attributes
    description: |
      Display a list of active Search Attributes that can be assigned or used with
      Workflow Queries. You can manage this list and add attributes as needed:

      ```
      temporal operator search-attribute list
      ```

  - name: temporal operator search-attribute remove
    summary: Remove custom Search Attributes
    description: |
      Remove custom Search Attributes from the options that can be assigned or used
      with Workflow Queries.

      ```
      temporal operator search-attribute remove \
          --name YourAttributeName
      ```

      Remove attributes without confirmation:

      ```
      temporal operator search-attribute remove \
          --name YourAttributeName \
          --yes
      ```
    options:
      - name: name
        type: string[]
        description: Search Attribute name.
        required: true
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm removal.

  - name: temporal schedule
    summary: Perform operations on Schedules
    description: |
      Create, use, and update Schedules that allow Workflow Executions to be created
      at specified times:

      ```
      temporal schedule [commands] [options]
      ```

      For example:

      ```
      temporal schedule describe \
          --schedule-id "YourScheduleId"
      ```
    option-sets:
      - client
    docs:
      description-header: >-
        Temporal's Schedule commands allow users to create, update, and manage
        Workflow Executions seamlessly for automation, supporting commands for
        creation, backfill, deletion, and more.
      keywords:
        - backfill
        - cli reference
        - command-line-interface-cli
        - schedule
        - schedule backfill
        - schedule create
        - schedule delete
        - schedule describe
        - schedule list
        - schedule toggle
        - schedule trigger
        - schedule update
        - temporal cli
        - updates
      tags:
        - Temporal CLI
        - Schedules

  - name: temporal schedule backfill
    summary: Backfill past actions
    description: |
      Batch-execute actions that would have run during a specified time interval.
      Use this command to fill in Workflow runs from when a Schedule was paused,
      before a Schedule was created, from the future, or to re-process a previously
      executed interval.

      Backfills require a Schedule ID and the time period covered by the request.
      It's best to use the `BufferAll` or `AllowAll` policies to avoid conflicts
      and ensure no Workflow Executions are skipped.

      For example:

      ```
      temporal schedule backfill \
          --schedule-id "YourScheduleId" \
          --start-time "2022-05-01T00:00:00Z" \
          --end-time "2022-05-31T23:59:59Z" \
          --overlap-policy BufferAll
      ```

      The policies include:

      * **AllowAll**: Allow unlimited concurrent Workflow Executions. This
        significantly speeds up the backfilling process on systems that support
        concurrency. You must ensure running Workflow Executions do not interfere
        with each other.
      * **BufferAll**: Buffer all incoming Workflow Executions while waiting for
        the running Workflow Execution to complete.
      * **Skip**: If a previous Workflow Execution is still running, discard new
        Workflow Executions.
      * **BufferOne**: Same as 'Skip' but buffer a single Workflow Execution to be
        run after the previous Execution completes. Discard other Workflow
        Executions.
      * **CancelOther**: Cancel the running Workflow Execution and replace it with
        the incoming new Workflow Execution.
      * **TerminateOther**: Terminate the running Workflow Execution and replace
        it with the incoming new Workflow Execution.
    options:
      - name: end-time
        type: timestamp
        description: Backfill end time.
        required: true
      - name: start-time
        type: timestamp
        description: Backfill start time.
        required: true
    option-sets:
      - overlap-policy
      - schedule-id

  - name: temporal schedule create
    summary: Create a new Schedule
    description: |
      Create a new Schedule on the Temporal Service. A Schedule automatically starts
      new Workflow Executions at the times you specify.

      For example:

      ```
        temporal schedule create \
          --schedule-id "YourScheduleId" \
          --calendar '{"dayOfWeek":"Fri","hour":"3","minute":"30"}' \
          --workflow-id YourBaseWorkflowIdName \
          --task-queue YourTaskQueue \
          --type YourWorkflowType
      ```

      Schedules support any combination of `--calendar`, `--interval`, and `--cron`:

      * Shorthand `--interval` strings.
        For example: 45m (every 45 minutes) or 6h/5h (every 6 hours, at the top of
        the 5th hour).
      * JSON `--calendar`, as in the preceding example.
      * Unix-style `--cron` strings and robfig declarations
        (@daily/@weekly/@every X/etc).
        For example, every Friday at 12:30 PM: `30 12 * * Fri`.
    option-sets:
      - schedule-configuration
      - schedule-create-only
      - schedule-id
      - overlap-policy
      - shared-workflow-start
      - payload-input

  - name: temporal schedule delete
    summary: Remove a Schedule
    description: |
      Deletes a Schedule on the front end Service:

      ```
      temporal schedule delete \
          --schedule-id YourScheduleId
      ```

      Removing a Schedule won't affect the Workflow Executions it started that are
      still running. To cancel or terminate these Workflow Executions, use `temporal
      workflow delete` with the `TemporalScheduledById` Search Attribute instead.
    option-sets:
      - schedule-id

  - name: temporal schedule describe
    summary: Display Schedule state
    description: |
      Show a Schedule configuration, including information about past, current, and
      future Workflow runs:

      ```
      temporal schedule describe \
          --schedule-id YourScheduleId
      ```
    option-sets:
      - schedule-id

  - name: temporal schedule list
    summary: Display hosted Schedules
    description: |
      Lists the Schedules hosted by a Namespace:

      ```
      temporal schedule list \
          --namespace YourNamespace
      ```
    options:
      - name: long
        short: l
        type: bool
        description: Show detailed information.
      - name: really-long
        type: bool
        description: Show extensive information in non-table form.
      - name: query
        short: q
        type: string
        description: Filter results using given List Filter.

  - name: temporal schedule toggle
    summary: Pause or unpause a Schedule
    description: |
      Pause or unpause a Schedule by passing a flag with your desired state:

      ```
      temporal schedule toggle \
          --schedule-id "YourScheduleId" \
          --pause \
          --reason "YourReason"
      ```

      and

      ```
      temporal schedule toggle
          --schedule-id "YourScheduleId" \
          --unpause \
          --reason "YourReason"
      ```

      The `--reason` text updates the Schedule's `notes` field for operations
      communication. It defaults to "(no reason provided)" if omitted. This field is
      also visible on the Service Web UI.
    options:
      - name: pause
        type: bool
        description: Pause the Schedule.
      - name: reason
        type: string
        description: Reason for pausing or unpausing the Schedule.
        default: "(no reason provided)"
      - name: unpause
        type: bool
        description: Unpause the Schedule.
    option-sets:
      - schedule-id

  - name: temporal schedule trigger
    summary: Immediately run a Schedule
    description: |
      Trigger a Schedule to run immediately:

      ```
      temporal schedule trigger \
          --schedule-id "YourScheduleId"
      ```
    option-sets:
      - schedule-id
      - overlap-policy

  - name: temporal schedule update
    summary: Update Schedule details
    description: |
      Update an existing Schedule with new configuration details, including time
      specifications, action, and policies:

      ```
      temporal schedule update \
          --schedule-id "YourScheduleId" \
          --workflow-type "NewWorkflowType"
      ```

      This command performs a full replacement of the Schedule
      configuration. Any options not provided will be reset to their default
      values. You must re-specify all options, not just the ones you want to
      change. To view the current configuration of a Schedule, use
      `temporal schedule describe` before updating.

      Schedule memo and search attributes cannot be updated with this
      command. They are set only during Schedule creation and are not affected
      by updates.
    option-sets:
      - schedule-configuration
      - schedule-id
      - overlap-policy
      - shared-workflow-start
      - payload-input

  - name: temporal server
    summary: Run Temporal Server
    description: |
      Run a development Temporal Server on your local system.

      ```
      +------------------------------------------------------------------------+
      | WARNING: The development server is not intended for production use.    |
      | It skips certain HTTP security checks to make local use simpler.       |
      |                                                                        |
      | For production use, see:                                               |
      | https://docs.temporal.io/production-deployment                         |
      +------------------------------------------------------------------------+
      ```

      View the Web UI for the default configuration at: http://localhost:8233

      ```
      temporal server start-dev
      ```

      Add persistence for Workflow Executions across runs:

      ```
      temporal server start-dev \
          --db-filename path-to-your-local-persistent-store
      ```

      Set the port from the front-end gRPC Service (7233 default):

      ```
      temporal server start-dev \
          --port 7234 \
          --ui-port 8234 \
          --metrics-port 57271
      ```

      Use a custom port for the Web UI. The default is the gRPC port (7233 default)
      plus 1000 (8233):

      ```
      temporal server start-dev \
          --ui-port 3000
      ```
    docs:
      description-header: >-
        Manage your Temporal Server easily with CLI commands. Start a local
        server using `temporal server start-dev` and access the Web UI at
        http://localhost:8233. Customize with multiple options.
      keywords:
        - cli reference
        - command-line-interface-cli
        - server
        - server start-dev
        - temporal cli
      tags:
        - Temporal CLI
        - Development Server

  - name: temporal server start-dev
    summary: Start Temporal development server
    description: |
      Run a development Temporal Server on your local system.

      ```
      +------------------------------------------------------------------------+
      | WARNING: The development server is not intended for production use.    |
      | It skips certain HTTP security checks to make local use simpler.       |
      |                                                                        |
      | For production use, see:                                               |
      | https://docs.temporal.io/production-deployment                         |
      +------------------------------------------------------------------------+
      ```

      View the Web UI for the default configuration at: http://localhost:8233

      ```
      temporal server start-dev
      ```

      Add persistence for Workflow Executions across runs:

      ```
      temporal server start-dev \
          --db-filename path-to-your-local-persistent-store
      ```

      Set the port from the front-end gRPC Service (7233 default):

      ```
      temporal server start-dev \
          --port 7000
      ```

      Use a custom port for the Web UI. The default is the gRPC port (7233 default)
      plus 1000 (8233):

      ```
      temporal server start-dev \
          --ui-port 3000
      ```
    options:
      - name: db-filename
        short: f
        type: string
        description: |
          Path to file for persistent Temporal state store.
          By default, Workflow Executions are lost when the server process dies.
      - name: namespace
        short: n
        type: string[]
        description: |
          Namespaces to be created at launch.
          The "default" Namespace is always created automatically.
      - name: port
        type: int
        short: p
        description: Port for the front-end gRPC Service.
        default: 7233
      - name: http-port
        type: int
        description: |
          Port for the HTTP API service.
          Defaults to a random free port.
        default: 0
      - name: metrics-port
        type: int
        description: |
          Port for the '/metrics' HTTP endpoint.
          Defaults to a random free port.
      - name: ui-port
        type: int
        description: |
          Port for the Web UI.
          Defaults to '--port' value + 1000.
      - name: headless
        type: bool
        description: Disable the Web UI.
      - name: ip
        type: string
        description: IP address bound to the front-end Service.
        default: localhost
      - name: ui-ip
        type: string
        description: |
          IP address bound to the Web UI.
          Defaults to same as '--ip' value.
      - name: ui-public-path
        type: string
        description: |
          The public base path for the Web UI.
          Defaults to `/`.
      - name: ui-asset-path
        type: string
        description: UI custom assets path.
      - name: ui-codec-endpoint
        type: string
        description: UI remote codec HTTP endpoint.
      - name: sqlite-pragma
        type: string[]
        description: SQLite pragma statements in "PRAGMA=VALUE" format.
      - name: dynamic-config-value
        type: string[]
        description: |
          Dynamic configuration value using `KEY=VALUE` pairs.
          Keys must be identifiers, and values must be JSON values.
          For example: `YourKey="YourString"`
          Can be passed multiple times.
      - name: log-config
        type: bool
        description: Print the server config to stderr.
      - name: search-attribute
        type: string[]
        description: |
          Search attributes to register using `KEY=VALUE` pairs.
          Keys must be identifiers, and values must be the search
          attribute type, which is one of the following:
          Text, Keyword, Int, Double, Bool, Datetime, KeywordList.

  - name: temporal task-queue
    summary: Manage Task Queues
    description: |
      Inspect and update Task Queues, the queues that Workers poll for Workflow and
      Activity tasks:

      ```
      temporal task-queue [command] [command options] \
          --task-queue YourTaskQueue
      ```

      For example:

      ```
      temporal task-queue describe \
          --task-queue YourTaskQueue
      ```
    option-sets:
      - client
    docs:
      description-header: >-
        Temporal Task Queue commands facilitate operations like describing
        poller info, displaying partitions, fetching compatible Build IDs,
        and determining Build ID reachability for effective Workflow and
        Activity management.
      keywords:
        - cli reference
        - command-line-interface-cli
        - list partitions
        - task queue
        - task queue describe
        - temporal cli
      tags:
        - Temporal CLI

  - name: temporal task-queue describe
    summary: Show active Workers
    description: |
      Display a list of active Workers that have recently polled a Task Queue. The
      Temporal Server records each poll request time. A `LastAccessTime` over one
      minute may indicate the Worker is at capacity or has shut down. Temporal
      Workers are removed if 5 minutes have passed since the last poll request.

      ```
      temporal task-queue describe \
        --task-queue YourTaskQueue
      ```

      This command provides poller information for a given Task Queue.
      Workflow and Activity polling use separate Task Queues:

      ```
      temporal task-queue describe \
          --task-queue YourTaskQueue \
          --task-queue-type "activity"
      ```

      This command provides the following task queue statistics:
      - `ApproximateBacklogCount`: The approximate number of tasks backlogged in this
        task queue. May count expired tasks but eventually converges to the right
        value.
      - `ApproximateBacklogAge`: Approximate age of the oldest task in the backlog,
        based on its creation time, measured in seconds.
      - `TasksAddRate`: Approximate rate at which tasks are being added to the task
        queue, measured in tasks per second, averaged over the last 30 seconds.
        Includes tasks dispatched immediately without going to the backlog
        (sync-matched tasks), as well as tasks added to the backlog. (See note below.)
      - `TasksDispatchRate`: Approximate rate at which tasks are being dispatched from
        the task queue, measured in tasks per second, averaged over the last 30
        seconds.  Includes tasks dispatched immediately without going to the backlog
        (sync-matched tasks), as well as tasks added to the backlog. (See note below.)
      - `BacklogIncreaseRate`: Approximate rate at which the backlog size is
        increasing (if positive) or decreasing (if negative), measured in tasks per
        second, averaged over the last 30 seconds.  This is roughly equivalent to:
        `TasksAddRate` - `TasksDispatchRate`.

      NOTE: The `TasksAddRate` and `TasksDispatchRate` metrics may differ from the
      actual rate of add/dispatch, because tasks may be dispatched eagerly to an
      available worker, or may apply only to specific workers (they are "sticky").
      Such tasks are not counted by these metrics. Despite the inaccuracy of
      these two metrics, the derived metric of `BacklogIncreaseRate` is accurate
      for backlogs older than a few seconds.

      Safely retire Workers assigned a Build ID by checking reachability across
      all task types. Use the flag `--report-reachability`:

      ```
      temporal task-queue describe \
          --task-queue YourTaskQueue \
          --select-build-id "YourBuildId" \
          --report-reachability
      ```

      Task reachability information is returned for the requested versions and all
      task types, which can be used to safely retire Workers with old code versions,
      provided that they were assigned a Build ID.

      Note that task reachability status is deprecated in favor of Drainage Status
      (ie. of a Drained or Draining Worker Deployment Version) and will be removed
      in a future release. Also, determining task reachability incurs a non-trivial
      computing cost.

      Task reachability states are reported per build ID. The state may be one of the
      following:

      - `Reachable`: using the current versioning rules, the Build ID may be used
        by new Workflow Executions or Activities OR there are currently open
        Workflow or backlogged Activity tasks assigned to the queue.
      - `ClosedWorkflowsOnly`: the Build ID does not have open Workflow Executions
        and can't be reached by new Workflow Executions. It MAY have closed
        Workflow Executions within the Namespace retention period.
      - `Unreachable`: this Build ID is not used for new Workflow Executions and
        isn't used by any existing Workflow Execution within the retention period.

      Task reachability is eventually consistent. You may experience a delay until
      reachability converges to the most accurate value. This is designed to act
      in the most conservative way until convergence. For example, `Reachable` is
      more conservative than `ClosedWorkflowsOnly`.
    options:
      - name: task-queue
        type: string
        short: t
        description: Task Queue name.
        required: true
      - name: task-queue-type
        type: string-enum[]
        description: Task Queue type. If not specified, all types are reported.
        enum-values:
          - workflow
          - activity
          - nexus
      - name: select-build-id
        type: string[]
        description: Filter the Task Queue based on Build ID.
      - name: select-unversioned
        type: bool
        description: Include the unversioned queue.
      - name: select-all-active
        type: bool
        description: |
          Include all active versions.
          A version is active if it had new tasks or polls recently.
      - name: report-reachability
        type: bool
        description: Display task reachability information.
      - name: legacy-mode
        type: bool
        description: |
          Enable a legacy mode for servers that do not support rules-based
          worker versioning.
          This mode only provides pollers info.
      - name: task-queue-type-legacy
        type: string-enum
        description: Task Queue type (legacy mode only).
        enum-values:
          - workflow
          - activity
        default: workflow
      - name: partitions-legacy
        type: int
        description: |
          Query partitions 1 through `N`.
          Experimental/Temporary feature.
          Legacy mode only.
        default: 1
      - name: disable-stats
        type: bool
        description: Disable task queue statistics.
      - name: report-config
        type: bool
        description: |
          Include task queue configuration in the response.
          When enabled, the command will return the current rate limit
          configuration for the task queue.

  - name: temporal task-queue get-build-id-reachability
    summary: Show Build ID availability (Deprecated)
    description: |
      ```
      +-----------------------------------------------------------------------------+
      | CAUTION: This command is deprecated and will be removed in a later release. |
      +-----------------------------------------------------------------------------+
      ```

      Show if a given Build ID can be used for new, existing, or closed Workflows
      in Namespaces that support Worker versioning:

      ```
      temporal task-queue get-build-id-reachability \
          --task-queue YourTaskQueue \
          --build-id "YourBuildId"
      ```

      You can specify the `--build-id` and `--task-queue` flags multiple times. If
      `--task-queue` is omitted, the command checks Build ID reachability against
      all Task Queues.
    options:
      - name: build-id
        type: string[]
        description: |
          One or more Build ID strings.
          Can be passed multiple times.
      - name: reachability-type
        type: string-enum
        description: |
          Reachability filter.
          `open`: reachable by one or more open workflows.
          `closed`: reachable by one or more closed workflows.
          `existing`: reachable by either.
          New Workflow Executions reachable by a Build ID are always reported.
        enum-values:
          - open
          - closed
          - existing
        default: existing
      - name: task-queue
        short: t
        type: string[]
        description: |
          Search only the specified task queue(s).
          Can be passed multiple times.

  - name: temporal task-queue get-build-ids
    summary: Fetch Build ID versions (Deprecated)
    description: |
      ```
      +-----------------------------------------------------------------------------+
      | CAUTION: This command is deprecated and will be removed in a later release. |
      +-----------------------------------------------------------------------------+
      ```

      Fetch sets of compatible Build IDs for specified Task Queues and display their
      information:

      ```
      temporal task-queue get-build-ids \
          --task-queue YourTaskQueue
      ```

      This command is limited to Namespaces that support Worker versioning.
    options:
      - name: task-queue
        type: string
        description: |
          Task Queue name.
        required: true
        short: t
      - name: max-sets
        type: int
        description: |
          Max return count.
          Use 1 for default major version.
          Use 0 for all sets.
        default: 0

  - name: temporal task-queue list-partition
    summary: List Task Queue partitions
    description: |
      Display a Task Queue's partition list with assigned matching nodes:

      ```
      temporal task-queue list-partition \
          --task-queue YourTaskQueue
      ```
    options:
      - name: task-queue
        type: string
        description: Task Queue name.
        required: true
        short: t

  - name: temporal task-queue update-build-ids
    summary: Manage Build IDs (Deprecated)
    description: |
      ```
      +-----------------------------------------------------------------------------+
      | CAUTION: This command is deprecated and will be removed in a later release. |
      +-----------------------------------------------------------------------------+
      ```

      Add or change a Task Queue's compatible Build IDs for Namespaces using Worker
      versioning:

      ```
      temporal task-queue update-build-ids [subcommands] [options] \
          --task-queue YourTaskQueue
      ```

  - name: temporal task-queue update-build-ids add-new-compatible
    summary: Add compatible Build ID
    description: |
      Add a compatible Build ID to a Task Queue's existing version set. Provide an
      existing Build ID and a new Build ID:

      ```
      temporal task-queue update-build-ids add-new-compatible \
          --task-queue YourTaskQueue \
          --existing-compatible-build-id "YourExistingBuildId" \
          --build-id "YourNewBuildId"
      ```

      The new ID is stored in the set containing the existing ID and becomes the new
      default for that set.

      This command is limited to Namespaces that support Worker versioning.
    options:
      - name: build-id
        type: string
        description: Build ID to be added.
        required: true
      - name: task-queue
        type: string
        description: Task Queue name.
        required: true
        short: t
      - name: existing-compatible-build-id
        type: string
        description: Pre-existing Build ID in this Task Queue.
        required: true
      - name: set-as-default
        type: bool
        description: Set the expanded Build ID set as the Task Queue default.

  - name: temporal task-queue update-build-ids add-new-default
    summary: Set new default Build ID set (Deprecated)
    description: |
      ```
      +-----------------------------------------------------------------------------+
      | CAUTION: This command is deprecated and will be removed in a later release. |
      +-----------------------------------------------------------------------------+
      ```

      Create a new Task Queue Build ID set, add a Build ID to it, and make it the
      overall Task Queue default. The new set will be incompatible with previous
      sets and versions.

      ```
      temporal task-queue update-build-ids add-new-default \
          --task-queue YourTaskQueue \
          --build-id "YourNewBuildId"
      ```

      ```
      +------------------------------------------------------------------------+
      | NOTICE: This command is limited to Namespaces that support Worker      |
      | versioning. Worker versioning is experimental. Versioning commands are |
      | subject to change.                                                     |
      +------------------------------------------------------------------------+
      ```
    options:
      - name: build-id
        type: string
        description: Build ID to be added.
        required: true
      - name: task-queue
        type: string
        description: Task Queue name.
        required: true
        short: t

  - name: temporal task-queue update-build-ids promote-id-in-set
    summary: Set Build ID as set default (Deprecated)
    description: |
      ```
      +-----------------------------------------------------------------------------+
      | CAUTION: This command is deprecated and will be removed in a later release. |
      +-----------------------------------------------------------------------------+
      ```

      Establish an existing Build ID as the default in its Task Queue set. New tasks
      compatible with this set will now be dispatched to this ID:

      ```
      temporal task-queue update-build-ids promote-id-in-set \
          --task-queue YourTaskQueue \
          --build-id "YourBuildId"
      ```

      ```
      +------------------------------------------------------------------------+
      | NOTICE: This command is limited to Namespaces that support Worker      |
      | versioning. Worker versioning is experimental. Versioning commands are |
      | subject to change.                                                     |
      +------------------------------------------------------------------------+
      ```
    options:
      - name: build-id
        type: string
        description: Build ID to set as default.
        required: true
      - name: task-queue
        type: string
        description: Task Queue name.
        required: true
        short: t

  - name: temporal task-queue update-build-ids promote-set
    summary: Promote Build ID set (Deprecated)
    description: |
      ```
      +-----------------------------------------------------------------------------+
      | CAUTION: This command is deprecated and will be removed in a later release. |
      +-----------------------------------------------------------------------------+
      ```

      Promote a Build ID set to be the default on a Task Queue. Identify the set by
      providing a Build ID within it. If the set is already the default, this
      command has no effect:

      ```
      temporal task-queue update-build-ids promote-set \
          --task-queue YourTaskQueue \
          --build-id "YourBuildId"
      ```

      ```
      +------------------------------------------------------------------------+
      | NOTICE: This command is limited to Namespaces that support Worker      |
      | versioning. Worker versioning is experimental. Versioning commands are |
      | subject to change.                                                     |
      +------------------------------------------------------------------------+
      ```
    options:
      - name: build-id
        type: string
        description: Build ID within the promoted set.
        required: true
      - name: task-queue
        type: string
        description: Task Queue name.
        required: true
        short: t

  - name: temporal task-queue versioning
    summary: Manage Task Queue Build ID handling (Deprecated)
    description: |
      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```

      Provides commands to add, list, remove, or replace Worker Build ID assignment
      and redirect rules associated with Task Queues:

      ```
      temporal task-queue versioning [subcommands] [options] \
          --task-queue YourTaskQueue
      ```

      Task Queues support the following versioning rules and policies:

      - Assignment Rules: manage how new executions are assigned to run on specific
        Worker Build IDs. Each Task Queue stores a list of ordered Assignment Rules,
        which are evaluated from first to last. Assignment Rules also allow for
        gradual rollout of new Build IDs by setting ramp percentage.
      - Redirect Rules: automatically assign work for a source Build ID to a target
        Build ID. You may add at most one redirect rule for each source Build ID.
        Redirect rules require that a target Build ID is fully compatible with
        the source Build ID.
    options:
      - name: task-queue
        type: string
        short: t
        description: Task queue name.
        required: true

  - name: temporal task-queue versioning add-redirect-rule
    summary: Add Task Queue redirect rules (Deprecated)
    description: |
      Add a new redirect rule for a given Task Queue. You may add at most one
      redirect rule for each distinct source build ID:

      ```
      temporal task-queue versioning add-redirect-rule \
          --task-queue YourTaskQueue \
          --source-build-id "YourSourceBuildID" \
          --target-build-id "YourTargetBuildID"
      ```

      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```
    options:
      - name: source-build-id
        type: string
        description: Source build ID.
        required: true
      - name: target-build-id
        type: string
        description: Target build ID.
        required: true
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm.

  - name: temporal task-queue versioning commit-build-id
    summary: Complete Build ID rollout (Deprecated)
    description: |
      Complete a Build ID's rollout and clean up unnecessary rules that might have
      been created during a gradual rollout:

      ```
      temporal task-queue versioning commit-build-id \
          --task-queue YourTaskQueue
          --build-id "YourBuildId"
      ```

      This command automatically applies the following atomic changes:

      - Adds an unconditional assignment rule for the target Build ID at the
        end of the list.
      - Removes all previously added assignment rules to the given target
        Build ID.
      - Removes any unconditional assignment rules for other Build IDs.

      Rejects requests when there have been no recent pollers for this Build ID.
      This prevents committing invalid Build IDs. Use the `--force` option to
      override this validation.

      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```
    options:
      - name: build-id
        type: string
        description: Target build ID.
        required: true
      - name: force
        type: bool
        description: Bypass recent-poller validation.
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm.

  - name: temporal task-queue versioning delete-assignment-rule
    summary: Removes a Task Queue assignment rule (Deprecated)
    description: |
      Deletes a rule identified by its index in the Task Queue's list of assignment
      rules.

      ```
      temporal task-queue versioning delete-assignment-rule \
          --task-queue YourTaskQueue \
          --rule-index YourIntegerRuleIndex
      ```

      By default, the Task Queue must retain one unconditional rule, such as "no
      hint filter" or "percentage". Otherwise, the delete operation is rejected.
      Use the `--force` option to override this validation.

      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```
    options:
      - name: rule-index
        type: int
        short: i
        description: |
          Position of the assignment rule to be replaced.
          Requests for invalid indices will fail.
        required: true
      - name: force
        type: bool
        description: Bypass one-unconditional-rule validation.
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm.

  - name: temporal task-queue versioning delete-redirect-rule
    summary: Removes Build-ID routing rule (Deprecated)
    description: |
      Deletes the routing rule for the given source Build ID.

      ```
      temporal task-queue versioning delete-redirect-rule \
          --task-queue YourTaskQueue \
          --source-build-id "YourBuildId"
      ```

      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```
    options:
      - name: source-build-id
        type: string
        description: Source Build ID.
        required: true
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm.

  - name: temporal task-queue versioning get-rules
    summary: Fetch Worker Build ID assignments and redirect rules (Deprecated)
    description: |
      Retrieve all the Worker Build ID assignments and redirect rules associated
      with a Task Queue:

      ```
      temporal task-queue versioning get-rules \
          --task-queue YourTaskQueue
      ```

      Task Queues support the following versioning rules:

      - Assignment Rules: manage how new executions are assigned to run on specific
        Worker Build IDs. Each Task Queue stores a list of ordered Assignment Rules,
        which are evaluated from first to last. Assignment Rules also allow for
        gradual rollout of new Build IDs by setting ramp percentage.
      - Redirect Rules: automatically assign work for a source Build ID to a target
        Build ID. You may add at most one redirect rule for each source Build ID.
        Redirect rules require that a target Build ID is fully compatible with
        the source Build ID.
      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```

  - name: temporal task-queue versioning insert-assignment-rule
    summary: Add an assignment rule at a index (Deprecated)
    description: |
      Inserts a new assignment rule for this Task Queue. Rules are evaluated in
      order, starting from index 0. The first applicable rule is applied, and the
      rest ignored:

      ```
      temporal task-queue versioning insert-assignment-rule \
          --task-queue YourTaskQueue \
          --build-id "YourBuildId"
      ```

      If you do not specify a `--rule-index`, this command inserts at index 0.

      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```
    options:
      - name: build-id
        type: string
        description: Target Build ID.
        required: true
      - name: rule-index
        type: int
        short: i
        description: |
          Insertion position.
          Ranges from 0 (insert at start) to count (append).
          Any number greater than the count is treated as "append".
        default: 0
      - name: percentage
        type: int
        description: |
          Traffic percent to send to target Build ID.
        default: 100
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm.

  - name: temporal task-queue versioning replace-assignment-rule
    summary: Update assignment rule at index (Deprecated)
    description: |
      Change an assignment rule for this Task Queue. By default, this enforces one
      unconditional rule (no hint filter or percentage). Otherwise, the operation
      will be rejected. Set `force` to true to bypass this validation.

      ```
      temporal task-queue versioning replace-assignment-rule \
          --task-queue YourTaskQueue \
          --rule-index AnIntegerIndex \
          --build-id "YourBuildId"
      ```

      To assign multiple assignment rules to a single Build ID, use
      'insert-assignment-rule'.

      To update the percent:

      ```
      temporal task-queue versioning replace-assignment-rule \
          --task-queue YourTaskQueue \
          --rule-index AnIntegerIndex \
          --build-id "YourBuildId" \
          --percentage AnIntegerPercent
      ```

      Percent may vary between 0 and 100 (default).

      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```
    options:
      - name: build-id
        type: string
        description: Target Build ID.
        required: true
      - name: rule-index
        type: int
        short: i
        description: |
          Position of the assignment rule to be replaced.
          Requests for invalid indices will fail.
        required: true
      - name: percentage
        type: int
        description: |
          Divert percent of traffic to target Build ID.
        default: 100
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm.
      - name: force
        type: bool
        description: Bypass the validation that one unconditional rule remains.

  - name: temporal task-queue versioning replace-redirect-rule
    summary: Change the target for a Build ID's redirect (Deprecated)
    description: |
      Updates a Build ID's redirect rule on a Task Queue by replacing its target
      Build ID:

      ```
      temporal task-queue versioning replace-redirect-rule \
          --task-queue YourTaskQueue \
          --source-build-id YourSourceBuildId \
          --target-build-id YourNewTargetBuildId
      ```

      ```
      +---------------------------------------------------------------------+
      | CAUTION: This API has been deprecated by Worker Deployment.         |
      +---------------------------------------------------------------------+
      ```
    options:
      - name: source-build-id
        type: string
        description: Source Build ID.
        required: true
      - name: target-build-id
        type: string
        description: Target Build ID.
        required: true
      - name: yes
        short: y
        type: bool
        description: Don't prompt to confirm.

  - name: temporal task-queue config
    summary: Get and set Task Queue configuration
    description: |
      Manage Task Queue configuration:

      ```
      temporal task-queue config [command] [options]
      ```

      Available commands:
      - `get`: Retrieve the current configuration for a task queue
      - `set`: Update the configuration for a task queue

  - name: temporal task-queue config get
    summary: Get Task Queue configuration
    description: |
      Retrieve the current configuration for a Task Queue:

      ```
      temporal task-queue config get \
          --task-queue YourTaskQueue \
          --task-queue-type activity
      ```

      This command returns the current configuration including:
      - Queue rate limit: The overall rate limit of the task queue.
        This setting overrides the worker rate limit if set.
        Unless modified, this is the system-defined rate limit.
      - Fairness key rate limit defaults: Default rate limits for fairness keys.
        If set, each individual fairness key will be limited to this rate,
        scaled by the weight of the fairness key.

    options:
      - name: task-queue
        type: string
        description: |
          Task Queue name.
        required: true
        short: t
      - name: task-queue-type
        type: string-enum
        description: |
          Task Queue type.
          Accepted values: workflow, activity, nexus.
        required: true
        enum-values:
          - workflow
          - activity
          - nexus

  - name: temporal task-queue config set
    summary: Set Task Queue configuration
    description: |
      Update configuration settings for a Task Queue.

      ```
      temporal task-queue config set \
          --task-queue YourTaskQueue \
          --task-queue-type activity \
          --namespace YourNamespace \
          --queue-rps-limit <requests_per_second:float> \
          --queue-rps-limit-reason <reason_string> \
          --fairness-key-rps-limit-default <requests_per_second:float> \
          --fairness-key-rps-limit-reason <reason_string> \
          --fairness-key-weight-set HighPriority=2.0 \
          --fairness-key-weight-set LowPriority=0.5
      ```

      This command supports updating:
      - Queue rate limits: Controls the overall rate limit of the task queue.
        This setting overrides the worker rate limit if set.
        Unless modified, this is the system-defined rate limit.
      - Fairness key rate limit defaults: Sets default rate limits for fairness keys.
        If set, each individual fairness key will be limited to this rate,
        scaled by the weight of the fairness key.
      - Fairness key weight overrides: Set custom weights for specific fairness keys.
        Weights control the relative share of capacity each key receives.

      To unset a rate limit, pass in 'default', for example: --queue-rps-limit default
      To unset specific fairness weights, use --fairness-key-weight-unset <key>
      To unset all fairness weights, use --fairness-key-weight-unset-all
    options:
      - name: task-queue
        type: string
        description: |
          Task Queue name.
        required: true
        short: t
      - name: task-queue-type
        type: string-enum
        description: |
          Task Queue type.
          Accepted values: workflow, activity, nexus.
        required: true
        enum-values:
          - workflow
          - activity
          - nexus
      - name: queue-rps-limit
        type: string
        display-type: float|default
        description: |
          Queue rate limit in requests per second.
          Accepts a float; or 'default' to unset.
      - name: queue-rps-limit-reason
        type: string
        description: Reason for queue rate limit update.
      - name: fairness-key-rps-limit-default
        type: string
        display-type: float|default
        description: |
          Fairness key rate limit default in requests per second.
          Accepts a float; or 'default' to unset.
      - name: fairness-key-rps-limit-reason
        type: string
        description: Reason for fairness key rate limit update.
      - name: fairness-key-weight
        type: string[]
        description: |
          Set or unset fairness key weight overrides in format key=weight or key=default.
          Use key=weight to set a positive weight value; use key=default to unset.
          Can be specified multiple times. Example: --fairness-key-weight HighPriority=2.0 --fairness-key-weight LowPriority=default.
      - name: fairness-key-weight-clear-all
        type: bool
        description: |
          Unset all fairness key weight overrides.
          Cannot be used with --fairness-key-weight.

  - name: temporal workflow
    summary: Start, list, and operate on Workflows
    description: |
      Workflow commands perform operations on Workflow Executions:

      ```
      temporal workflow [command] [options]
      ```

      For example:

      ```
      temporal workflow list
      ```
    option-sets:
      - client
    docs:
      description-header: >-
        Temporal Workflow commands enable operations on Workflow Executions,
        such as cancel, count, delete, describe, execute, list, update-options,
        query, reset, reset-batch, show, signal, stack, start, terminate,
        trace, and update, enhancing efficiency and control.
      keywords:
        - call stack
        - cancellation
        - child workflows
        - cli reference
        - command-line-interface-cli
        - event history
        - query
        - resets-feature
        - signals
        - signals-feature
        - stack trace
        - temporal cli
        - termination
        - workflow
        - workflow cancel
        - workflow count
        - workflow delete
        - workflow describe
        - workflow execute
        - workflow execution
        - workflow list
        - workflow metadata
        - workflow query
        - workflow reset
        - workflow reset-batch
        - workflow show
        - workflow signal
        - workflow stack
        - workflow start
        - workflow terminate
        - workflow trace
        - workflow update-options
      tags:
        - Temporal CLI
        - Workflows

  - name: temporal workflow cancel
    summary: Send cancellation to Workflow Execution
    description: |
      Canceling a running Workflow Execution records a
      `WorkflowExecutionCancelRequested` event in the Event History. The Service
      schedules a new Command Task, and the Workflow Execution performs any cleanup
      work supported by its implementation.

      Use the Workflow ID to cancel an Execution:

      ```
      temporal workflow cancel \
          --workflow-id YourWorkflowId
      ```

      A visibility Query lets you send bulk cancellations to Workflow Executions
      matching the results:

      ```
      temporal workflow cancel \
          --query YourQuery
      ```

      Visit https://docs.temporal.io/visibility to read more about Search Attributes
      and Query creation. See `temporal batch --help` for a quick reference.
    option-sets:
      - single-workflow-or-batch

  - name: temporal workflow count
    summary: Number of Workflow Executions
    description: |
      Show a count of Workflow Executions, regardless of execution state (running,
      terminated, etc). Use `--query` to select a subset of Workflow Executions:

      ```
      temporal workflow count \
          --query YourQuery
      ```

      Visit https://docs.temporal.io/visibility to read more about Search Attributes
      and Query creation. See `temporal batch --help` for a quick reference.
    options:
      - name: query
        type: string
        short: q
        description: Content for an SQL-like `QUERY` List Filter.

  - name: temporal workflow delete
    summary: Remove Workflow Execution
    description: |
      Delete a Workflow Executions and its Event History:

      ```
      temporal workflow delete \
          --workflow-id YourWorkflowId
      ```

      The removal executes asynchronously. If the Execution is Running, the Service
      terminates it before deletion.

      Visit https://docs.temporal.io/visibility to read more about Search Attributes
      and Query creation. See `temporal batch --help` for a quick reference.
    option-sets:
      - single-workflow-or-batch

  - name: temporal workflow describe
    summary: Show Workflow Execution info
    description: |
      Display information about a specific Workflow Execution:

      ```
      temporal workflow describe \
          --workflow-id YourWorkflowId
      ```

      Show the Workflow Execution's auto-reset points:

      ```
      temporal workflow describe \
          --workflow-id YourWorkflowId \
          --reset-points true
      ```
    option-sets:
      - workflow-reference
    options:
      - name: reset-points
        type: bool
        description: Show auto-reset points only.
      - name: raw
        type: bool
        description: Print properties without changing their format.

  - name: temporal workflow execute
    summary: Start new Workflow Execution
    description: |
      Establish a new Workflow Execution and direct its progress to stdout. The
      command blocks and returns when the Workflow Execution completes. If your
      Workflow requires input, pass valid JSON:

      ```
      temporal workflow execute
          --workflow-id YourWorkflowId \
          --type YourWorkflow \
          --task-queue YourTaskQueue \
          --input '{"some-key": "some-value"}'
      ```

      Use `--event-details` to relay updates to the command-line output in JSON
      format. When using JSON output (`--output json`), this includes the entire
      "history" JSON key for the run.
    option-sets:
      - shared-workflow-start
      - workflow-start
      - payload-input
    options:
      - name: detailed
        type: bool
        description: |
          Display events as sections instead of table.
          Does not apply to JSON output.

  - name: temporal workflow fix-history-json
    summary: Updates an event history JSON file
    description: |
      Reserialize an Event History JSON file:

      ```
      temporal workflow fix-history-json \
          --source /path/to/original.json \
          --target /path/to/reserialized.json
      ```
    options:
      - name: source
        short: s
        type: string
        description: Path to the original file.
        required: true
      - name: target
        short: t
        type: string
        description: |
          Path to the results file.
          When omitted, output is sent to stdout.

  - name: temporal workflow list
    summary: Show Workflow Executions
    description: |
      List Workflow Executions. The optional `--query` limits the output to
      Workflows matching a Query:

      ```
      temporal workflow list \
          --query YourQuery
      ```

      Visit https://docs.temporal.io/visibility to read more about Search Attributes
      and Query creation. See `temporal batch --help` for a quick reference.

      View a list of archived Workflow Executions:

      ```
      temporal workflow list \
          --archived
      ```
    options:
      - name: query
        short: q
        type: string
        description: Content for an SQL-like `QUERY` List Filter.
      - name: archived
        type: bool
        experimental: true
        description: Limit output to archived Workflow Executions.
      - name: limit
        type: int
        description: Maximum number of Workflow Executions to display.
      - name: page-size
        type: int
        description: Maximum number of Workflow Executions to fetch at a time from the server.

  - name: temporal workflow metadata
    summary: Query the Workflow for user-specified metadata
    description: |
      Issue a Query for and display user-set metadata like summary and
      details for a specific Workflow Execution:

      ```
      temporal workflow metadata \
          --workflow-id YourWorkflowId
      ```
    option-sets:
      - workflow-reference
      - query-modifiers

  - name: temporal workflow update-options
    summary: Change Workflow Execution Options
    description: |
      Modify properties of Workflow Executions:

      ```
      temporal workflow update-options [options]
      ```

      It can override the Worker Deployment configuration of a
      Workflow Execution, which controls Worker Versioning.

      For example, to force Workers in the current Deployment execute the
      next Workflow Task change behavior to `auto_upgrade`:

      ```
      temporal workflow update-options \
          --workflow-id YourWorkflowId \
          --versioning-override-behavior auto_upgrade
      ```

      or to pin the workflow execution to a Worker Deployment, set behavior
      to `pinned`:

      ```
      temporal workflow update-options \
          --workflow-id YourWorkflowId \
          --versioning-override-behavior pinned \
          --versioning-override-deployment-name YourDeploymentName \
          --versioning-override-build-id YourDeploymentBuildId
      ```

      To remove any previous overrides, set the behavior to
      `unspecified`:

      ```
      temporal workflow update-options \
          --workflow-id YourWorkflowId \
          --versioning-override-behavior unspecified
      ```

      To see the current override use `temporal workflow describe`

    option-sets:
      - single-workflow-or-batch
    options:
      - name: versioning-override-behavior
        type: string-enum
        description: |
          Override the versioning behavior of a Workflow.
        required: true
        enum-values:
          - unspecified
          - pinned
          - auto_upgrade
      - name: versioning-override-deployment-name
        type: string
        description:
          When overriding to a `pinned` behavior, specifies the Deployment Name of the
          version to target.
      - name: versioning-override-build-id
        type: string
        description:
          When overriding to a `pinned` behavior, specifies the Build ID of the
          version to target.
  - name: temporal workflow query
    summary: Retrieve Workflow Execution state
    description: |
      Send a Query to a Workflow Execution by Workflow ID to retrieve its state.
      This synchronous operation exposes the internal state of a running Workflow
      Execution, which constantly changes. You can query both running and completed
      Workflow Executions:

      ```
      temporal workflow query \
          --workflow-id YourWorkflowId
          --type YourQueryType
          --input '{"YourInputKey": "YourInputValue"}'
      ```
    option-sets:
      - payload-input
      - workflow-reference
      - query-modifiers
    options:
      - name: name
        type: string
        description: Query Type/Name.
        required: true
        aliases:
          - type

  - name: temporal workflow reset
    summary: Move Workflow Execution history point
    subcommands-optional: true
    description: |
      Reset a Workflow Execution so it can resume from a point in its Event History
      without losing its progress up to that point:

      ```
      temporal workflow reset \
          --workflow-id YourWorkflowId \
          --event-id YourLastEvent
      ```

      Start from where the Workflow Execution last continued as new:

      ```
      temporal workflow reset \
          --workflow-id YourWorkflowId \
          --type LastContinuedAsNew
      ```

      For batch resets, limit your resets to FirstWorkflowTask, LastWorkflowTask, or
      BuildId. Do not use Workflow IDs, run IDs, or event IDs with this command.

      Visit https://docs.temporal.io/visibility to read more about Search
      Attributes and Query creation.
    options:
      - name: workflow-id
        short: w
        type: string
        description: |
          Workflow ID.
          Required for non-batch reset operations.
      - name: run-id
        short: r
        type: string
        description: Run ID.
      - name: event-id
        short: e
        type: int
        description: |
          Event ID to reset to.
          Event must occur after `WorkflowTaskStarted`.
          `WorkflowTaskCompleted`, `WorkflowTaskFailed`, etc. are valid.
      - name: reason
        type: string
        description: Reason for reset.
        required: true
      - name: reapply-type
        type: string-enum
        description: Types of events to re-apply after reset point.
        deprecated: Use --reapply-exclude instead.
        enum-values:
          - All
          - Signal
          - None
        default: All
      - name: reapply-exclude
        type: string-enum[]
        description: Exclude these event types from re-application.
        enum-values:
          - All
          - Signal
          - Update
      - name: type
        short: t
        type: string-enum
        description: The event type for the reset.
        enum-values:
          - FirstWorkflowTask
          - LastWorkflowTask
          - LastContinuedAsNew
          - BuildId
      - name: build-id
        type: string
        description: |
          A Build ID.
          Use only with the BuildId `--type`.
          Resets the first Workflow task processed by this ID.
          By default, this reset may be in a prior run, earlier than a Continue
          as New point.
      - name: query
        short: q
        type: string
        description: Content for an SQL-like `QUERY` List Filter.
      - name: yes
        short: y
        type: bool
        description: |
          Don't prompt to confirm.
          Only allowed when `--query` is present.

  - name: temporal workflow reset with-workflow-update-options
    summary: Update options on reset workflow
    description: |
      Run Workflow Update Options atomically after the Workflow is reset.
      Workflows selected by the reset command are forwarded onto the subcommand.
    option-sets:
      - workflow-update-options

  - name: temporal workflow result
    summary: Wait for and show the result of a Workflow Execution
    description: |
      Wait for and print the result of a Workflow Execution:

      ```
      temporal workflow result \
          --workflow-id YourWorkflowId
      ```
    option-sets:
      - workflow-reference

  - name: temporal workflow show
    summary: Display Event History
    description: |
      Show a Workflow Execution's Event History.
      When using JSON output (`--output json`), you may pass the results to an SDK
      to perform a replay:

      ```
      temporal workflow show \
          --workflow-id YourWorkflowId
          --output json
      ```
    options:
      - name: follow
        short: f
        type: bool
        description: |
          Follow the Workflow Execution progress in real time.
          Does not apply to JSON output.
      - name: detailed
        type: bool
        description: |
          Display events as detailed sections instead of table.
          Does not apply to JSON output.
      - name: reverse
        type: bool
        description: |
          Fetch Event History newest-event-first. Cannot be combined with --follow.
    option-sets:
      - workflow-reference

  - name: temporal workflow signal
    summary: Send a message to a Workflow Execution
    description: |
      Send an asynchronous notification (Signal) to a running Workflow Execution by
      its Workflow ID. The Signal is written to the History. When you include
      `--input`, that data is available for the Workflow Execution to consume:

      ```
      temporal workflow signal \
          --workflow-id YourWorkflowId \
          --name YourSignal \
          --input '{"YourInputKey": "YourInputValue"}'
      ```

      Visit https://docs.temporal.io/visibility to read more about Search Attributes
      and Query creation. See `temporal batch --help` for a quick reference.
    option-sets:
      - single-workflow-or-batch
      - payload-input
    options:
      - name: name
        type: string
        description: Signal name.
        required: true
        aliases:
          - type

  - name: temporal workflow signal-with-start
    summary: Send a message to a Workflow Execution, start the execution if it isn't running
    description: |
      Send an asynchronous notification (Signal) to a Workflow Execution.
      If the Workflow Execution is not running or is not found, it starts the
      workflow then sends the signal.

      ```
      temporal workflow signal-with-start \
        --signal-name YourSignal \
        --signal-input '{"some-key": "some-value"}' \
        --workflow-id YourWorkflowId \
        --type YourWorkflowType \
        --task-queue YourTaskQueue \
        --input '{"some-key": "some-value"}'
      ```
    option-sets:
      # workflow-id is "required" (runtime check)
      - shared-workflow-start
      - workflow-start
      - payload-input
    options:
      - name: signal-name
        type: string
        description: Signal name.
        required: true
        aliases:
          - signal-type
      - name: signal-input
        type: string[]
        description: |
          Signal input value.
          Use JSON content or set --signal-input-meta to override.
          Can't be combined with --signal-input-file.
          Can be passed multiple times to pass multiple arguments.
      - name: signal-input-file
        type: string[]
        description: |
          A path or paths for input file(s).
          Use JSON content or set --signal-input-meta to override.
          Can't be combined with --signal-input.
          Can be passed multiple times to pass multiple arguments.
      - name: signal-input-meta
        type: string[]
        description: |
          Input signal payload metadata as a `KEY=VALUE` pair.
          When the KEY is "encoding", this overrides the default ("json/plain").
          Can be passed multiple times.
      - name: signal-input-base64
        type: bool
        description: |
          Assume signal inputs are base64-encoded and attempt to decode them.

  - name: temporal workflow stack
    summary: Trace a Workflow Execution
    description: |
      Perform a Query on a Workflow Execution using a `__stack_trace`-type Query.
      Display a stack trace of the threads and routines currently in use by the
      Workflow for troubleshooting:

      ```
      temporal workflow stack \
          --workflow-id YourWorkflowId
      ```
    options:
      - name: reject-condition
        type: string-enum
        description: Optional flag to reject Queries based on Workflow state.
        enum-values:
          - not_open
          - not_completed_cleanly
    option-sets:
      - workflow-reference

  - name: temporal workflow start
    summary: Initiate a Workflow Execution
    description: |
      Start a new Workflow Execution. Returns the Workflow- and Run-IDs:

      ```
      temporal workflow start \
          --workflow-id YourWorkflowId \
          --type YourWorkflow \
          --task-queue YourTaskQueue \
          --input '{"some-key": "some-value"}'
      ```
    option-sets:
      - shared-workflow-start
      - workflow-start
      - payload-input

  - name: temporal workflow terminate
    summary: Forcefully end a Workflow Execution
    description: |
      Terminate a Workflow Execution:

      ```
      temporal workflow terminate \
          --reason YourReasonForTermination \
          --workflow-id YourWorkflowId
      ```

      The reason is optional and defaults to the current user's name. The reason
      is stored in the Event History as part of the `WorkflowExecutionTerminated`
      event. This becomes the closing Event in the Workflow Execution's history.

      Executions may be terminated in bulk via a visibility Query list filter:

      ```
      temporal workflow terminate \
          --query YourQuery \
          --reason YourReasonForTermination
      ```

      Workflow code cannot see or respond to terminations. To perform clean-up work
      in your Workflow code, use `temporal workflow cancel` instead.

      Visit https://docs.temporal.io/visibility to read more about Search Attributes
      and Query creation. See `temporal batch --help` for a quick reference.
    options:
      - name: workflow-id
        short: w
        type: string
        description: |
          Workflow ID.
          You must set either --workflow-id or --query.
      - name: query
        short: q
        type: string
        description: |
          Content for an SQL-like `QUERY` List Filter.
          You must set either --workflow-id or --query.
      - name: run-id
        short: r
        type: string
        description: |
          Run ID.
          Can only be set with --workflow-id.
          Do not use with --query.
      - name: reason
        type: string
        description: |
          Reason for termination.
          Defaults to message with the current user's name.
      - name: yes
        short: y
        type: bool
        description: |
          Don't prompt to confirm termination.
          Can only be used with --query.
      - name: rps
        type: float
        description: |
          Limit batch's requests per second.
          Only allowed if query is present.

  - name: temporal workflow trace
    summary: Workflow Execution live progress
    description: |
      Display the progress of a Workflow Execution and its child workflows with a
      real-time trace. This view helps you understand how Workflows are proceeding:

      ```
      temporal workflow trace \
          --workflow-id YourWorkflowId
      ```
    options:
      - name: fold
        type: string[]
        description: |
          Fold away Child Workflows with the specified statuses.
          Case-insensitive.
          Ignored if --no-fold supplied.
          Available values: running, completed, failed, canceled, terminated,
          timedout, continueasnew.
          Can be passed multiple times.
      - name: no-fold
        type: bool
        description: |
          Disable folding.
          Fetch and display Child Workflows within the set depth.
      - name: depth
        type: int
        description: |
          Set depth for your Child Workflow fetches.
          Pass -1 to fetch child workflows at any depth.
        default: -1
      - name: concurrency
        type: int
        description: |
          Number of Workflow Histories to fetch at a time.
        default: 10
    option-sets:
      - workflow-reference

  - name: temporal workflow update
    summary: Send and interact with Updates
    description: |
      An Update is a synchronous call to a Workflow Execution that can change its
      state, control its flow, and return a result.

  - name: temporal workflow update describe
    summary: Obtain status info about a specific Update
    description: |
      Given a Workflow Execution and an Update ID, return information about its current status, including
      a result if it has finished.

      ```
      temporal workflow update describe \
          --workflow-id YourWorkflowId \
          --update-id YourUpdateId
      ```
    option-sets:
      - update-targeting

  - name: temporal workflow update execute
    summary: Send an Update and wait for it to complete
    description: |
      Send a message to a Workflow Execution to invoke an Update handler, and wait for
      the update to complete or fail. You can also use this to wait for an existing
      update to complete, by submitting an existing update ID.

      ```
      temporal workflow update execute \
          --workflow-id YourWorkflowId \
          --name YourUpdate \
          --input '{"some-key": "some-value"}'
      ```
    option-sets:
      - update-starting
      - payload-input

  - name: temporal workflow update result
    summary: Wait for a specific Update to complete
    description: |
      Given a Workflow Execution and an Update ID, wait for the Update to complete or fail and
      print the result.

      ```
      temporal workflow update result \
          --workflow-id YourWorkflowId \
          --update-id YourUpdateId
      ```
    option-sets:
      - update-targeting

  - name: temporal workflow update start
    summary: Send an Update and wait for it to be accepted or rejected
    description: |
      Send a message to a Workflow Execution to invoke an Update handler, and wait for
      the update to be accepted or rejected. You can subsequently wait for the update
      to complete by using `temporal workflow update execute`.

      ```
      temporal workflow update start \
          --workflow-id YourWorkflowId \
          --name YourUpdate \
          --input '{"some-key": "some-value"}'
          --wait-for-stage accepted
      ```
    option-sets:
      - update-starting
      - payload-input
    options:
      - name: wait-for-stage
        type: string-enum
        description: |
          Update stage to wait for.
          The only option is `accepted`, but this option is  required. This is to allow
          a future version of the CLI to choose a default value.
        enum-values:
          - accepted
        required: true

  - name: temporal workflow start-update-with-start
    summary: Send an Update-With-Start and wait for it to be accepted or rejected (Experimental)
    description: |
      Send a message to a Workflow Execution to invoke an Update handler, and wait for
      the update to be accepted or rejected. If the Workflow Execution is not running,
      then a new workflow execution is started and the update is sent.

      Experimental.

      ```
      temporal workflow start-update-with-start \
        --update-name YourUpdate \
        --update-input '{"update-key": "update-value"}' \
        --update-wait-for-stage accepted \
        --workflow-id YourWorkflowId \
        --type YourWorkflowType \
        --task-queue YourTaskQueue \
        --id-conflict-policy Fail \
        --input '{"wf-key": "wf-value"}'
      ```
    option-sets:
      # workflow-id and id-conflict-policy are "required" (runtime checks)
      - shared-workflow-start
      - workflow-start
      - payload-input
    options:
      - name: update-name
        type: string
        description: Update name.
        required: true
        aliases:
          - update-type
      - name: update-first-execution-run-id
        type: string
        description: |
          Parent Run ID.
          The update is sent to the last Workflow Execution in the chain started
          with this Run ID.
      - name: update-wait-for-stage
        type: string-enum
        description: |
          Update stage to wait for.
          The only option is `accepted`, but this option is required. This is to allow
          a future version of the CLI to choose a default value.
        enum-values:
          - accepted
        required: true
      - name: update-id
        type: string
        description: |
          Update ID.
          If unset, defaults to a UUID.
      - name: run-id
        type: string
        short: r
        description: |
          Run ID.
          If unset, looks for an Update against the currently-running Workflow Execution.
      - name: update-input
        type: string[]
        description: |
          Update input value.
          Use JSON content or set --update-input-meta to override.
          Can't be combined with --update-input-file.
          Can be passed multiple times to pass multiple arguments.
      - name: update-input-file
        type: string[]
        description: |
          A path or paths for input file(s).
          Use JSON content or set --update-input-meta to override.
          Can't be combined with --update-input.
          Can be passed multiple times to pass multiple arguments.
      - name: update-input-meta
        type: string[]
        description: |
          Input update payload metadata as a `KEY=VALUE` pair.
          When the KEY is "encoding", this overrides the default ("json/plain").
          Can be passed multiple times.
      - name: update-input-base64
        type: bool
        description: |
          Assume update inputs are base64-encoded and attempt to decode them.

  - name: temporal workflow execute-update-with-start
    summary: Send an Update-With-Start and wait for it to complete (Experimental)
    description: |
      Send a message to a Workflow Execution to invoke an Update handler, and wait for
      the update to complete. If the Workflow Execution is not running, then a new workflow
      execution is started and the update is sent.

      Experimental.

      ```
      temporal workflow execute-update-with-start \
        --update-name YourUpdate \
        --update-input '{"update-key": "update-value"}' \
        --workflow-id YourWorkflowId \
        --type YourWorkflowType \
        --task-queue YourTaskQueue \
        --id-conflict-policy Fail \
        --input '{"wf-key": "wf-value"}'
      ```

    option-sets:
      # workflow-id and id-conflict-policy are "required" (runtime checks)
      - shared-workflow-start
      - workflow-start
      - payload-input
    options:
      - name: update-name
        type: string
        description: Update name.
        required: true
        aliases:
          - update-type
      - name: update-first-execution-run-id
        type: string
        description: |
          Parent Run ID.
          The update is sent to the last Workflow Execution in the chain started
          with this Run ID.
      - name: update-id
        type: string
        description: |
          Update ID.
          If unset, defaults to a UUID.
      - name: run-id
        type: string
        short: r
        description: |
          Run ID.
          If unset, looks for an Update against the currently-running Workflow Execution.
      - name: update-input
        type: string[]
        description: |
          Update input value.
          Use JSON content or set --update-input-meta to override.
          Can't be combined with --update-input-file.
          Can be passed multiple times to pass multiple arguments.
      - name: update-input-file
        type: string[]
        description: |
          A path or paths for input file(s).
          Use JSON content or set --update-input-meta to override.
          Can't be combined with --update-input.
          Can be passed multiple times to pass multiple arguments.
      - name: update-input-meta
        type: string[]
        description: |
          Input update payload metadata as a `KEY=VALUE` pair.
          When the KEY is "encoding", this overrides the default ("json/plain").
          Can be passed multiple times.
      - name: update-input-base64
        type: bool
        description: |
          Assume update inputs are base64-encoded and attempt to decode them.

  - name: temporal workflow pause
    summary: 'Pause a Workflow Execution (Experimental feature)'
    description: |
      Pause a Workflow Execution.
      Note: This is an experimental feature and may change in the future.
    options:
      - name: reason
        type: string
        description: |
          Reason for pausing the Workflow Execution.
          Defaults to message with the current user's name.
    option-sets:
      - workflow-reference

  - name: temporal workflow unpause
    summary: 'Unpause a previously paused Workflow Execution (Experimental feature)'
    description: |
      Unpause a previously paused Workflow Execution.
      Note: This is an experimental feature and may change in the future.
    options:
      - name: reason
        type: string
        description: |
          Reason for unpausing the Workflow Execution.
          Defaults to message with the current user's name.
    option-sets:
      - workflow-reference

option-sets:
  # Import common and client option sets from cliext package
  - name: common
    external-package: github.com/temporalio/cli/cliext
  - name: client
    external-package: github.com/temporalio/cli/cliext

  - name: overlap-policy
    options:
      - name: overlap-policy
        type: string-enum
        description: Policy for handling overlapping Workflow Executions. # copilot updated this
        enum-values:
          - Skip
          - BufferOne
          - BufferAll
          - CancelOther
          - TerminateOther
          - AllowAll
        default: Skip

  - name: schedule-id
    options:
      - name: schedule-id
        type: string
        description: Schedule ID.
        required: true
        short: s

  - name: schedule-configuration
    options:
      - name: calendar
        type: string[]
        description: |
          Calendar specification in JSON.
          For example: `{"dayOfWeek":"Fri","hour":"17","minute":"5"}`.
      - name: catchup-window
        type: duration
        description: Maximum catch-up time for when the Service is unavailable.
      - name: cron
        type: string[]
        description: |
          Calendar specification in cron string format.
          For example: `"30 12 * * Fri"`.
      - name: end-time
        type: timestamp
        description: Schedule end time.
      - name: interval
        type: string[]
        description: |
          Interval duration.
          For example, 90m, or 60m/15m to include phase offset.
      - name: jitter
        type: duration
        description: |
          Max difference in time from the specification.
          Vary the start time randomly within this amount.
      - name: notes
        type: string
        description: Initial notes field value.
      - name: paused
        type: bool
        description: Pause the Schedule immediately on creation.
      - name: pause-on-failure
        type: bool
        description: Pause schedule after Workflow failures.
      - name: remaining-actions
        type: int
        description: |
          Total allowed actions.
          Default is zero (unlimited).
      - name: start-time
        type: timestamp
        description: Schedule start time.
      - name: time-zone
        type: string
        description: |
          Interpret calendar specs with the `TZ` time zone.
          For a list of time zones, see:
          https://en.wikipedia.org/wiki/List_of_tz_database_time_zones.

  - name: schedule-create-only
    options:
      - name: schedule-search-attribute
        type: string[]
        description: |
          Set schedule Search Attributes using `KEY="VALUE` pairs.
          Keys must be identifiers, and values must be JSON values.
          For example: 'YourKey={"your": "value"}'.
          Can be passed multiple times.
      - name: schedule-memo
        type: string[]
        description: |
          Set schedule memo using `KEY="VALUE` pairs.
          Keys must be identifiers, and values must be JSON values.
          For example: 'YourKey={"your": "value"}'.
          Can be passed multiple times.

  - name: workflow-reference
    options:
      - name: workflow-id
        type: string
        short: w
        description: Workflow ID.
        required: true
      - name: run-id
        type: string
        short: r
        description: Run ID.

  - name: deployment-name
    options:
      - name: name
        type: string
        short: d
        description: Name for a Worker Deployment.
        required: true

  - name: deployment-version
    options:
      - name: deployment-name
        type: string
        description: |
          Name of the Worker Deployment.
        required: true
      - name: build-id
        type: string
        description: |
          Build ID of the Worker Deployment Version.
        required: true

  - name: deployment-version-or-unversioned
    options:
      - name: deployment-name
        type: string
        description: |
          Name of the Worker Deployment.
        required: true
      - name: build-id
        type: string
        description: |
          Build ID of the Worker Deployment Version.
          Required unless --unversioned is specified.
      - name: unversioned
        type: bool
        description: |
          Set unversioned workers as the target version.
          Cannot be used with --build-id.
  - name: deployment-reference
    options:
      - name: series-name
        type: string
        description: Series Name for a Worker Deployment.
        required: true
      - name: build-id
        type: string
        description: Build ID for a Worker Deployment.
        required: true

  # Duplicate of single-workflow-or-batch with an experimental note on --query.
  # Cannot extend the shared option set because workflow commands that also use
  # it (workflow cancel, workflow count, etc.) are not experimental.
  - name: single-activity-or-batch
    options:
      - name: workflow-id
        type: string
        short: w
        description: |
          Workflow ID.
          You must set either --workflow-id or --query.
      - name: query
        type: string
        short: q
        description: |
          Content for an SQL-like `QUERY` List Filter.
          You must set either --workflow-id or --query.
          Note: Using --query for batch activity operations is an experimental feature and may change in the future.
      - name: run-id
        type: string
        short: r
        description: |
          Run ID.
          Only use with --workflow-id.
          Cannot use with --query.
      - name: reason
        type: string
        description: |
          Reason for batch operation.
          Only use with --query.
          Defaults to user name.
      - name: yes
        type: bool
        short: y
        description: |
          Don't prompt to confirm signaling.
          Only allowed when --query is present.
      - name: rps
        type: float
        description: |
          Limit batch's requests per second.
          Only allowed if query is present.
      - name: headers
        type: string[]
        description: |
          Temporal workflow headers in 'KEY=VALUE' format.
          Keys must be identifiers, and values must be JSON values.
          May be passed multiple times to set multiple Temporal headers.
          Note: These are workflow headers, not gRPC headers.

  - name: single-workflow-or-batch
    options:
      - name: workflow-id
        type: string
        short: w
        description: |
          Workflow ID.
          You must set either --workflow-id or --query.
      - name: query
        type: string
        short: q
        description: |
          Content for an SQL-like `QUERY` List Filter.
          You must set either --workflow-id or --query.
      - name: run-id
        type: string
        short: r
        description: |
          Run ID.
          Only use with --workflow-id.
          Cannot use with --query.
      - name: reason
        type: string
        description: |
          Reason for batch operation.
          Only use with --query.
          Defaults to user name.
      - name: yes
        type: bool
        short: y
        description: |
          Don't prompt to confirm signaling.
          Only allowed when --query is present.
      - name: rps
        type: float
        description: |
          Limit batch's requests per second.
          Only allowed if query is present.
      - name: headers
        type: string[]
        description: |
          Temporal workflow headers in 'KEY=VALUE' format.
          Keys must be identifiers, and values must be JSON values.
          May be passed multiple times to set multiple Temporal headers.
          Note: These are workflow headers, not gRPC headers.

  - name: shared-workflow-start
    options:
      - name: workflow-id
        type: string
        short: w
        description: |
          Workflow ID.
          If not supplied, the Service generates a unique ID.
      - name: type
        type: string
        description: Workflow Type name.
        required: true
        aliases:
          - name
      - name: task-queue
        type: string
        description: Workflow Task queue.
        required: true
        short: t
      - name: run-timeout
        type: duration
        description: |
          Fail a Workflow Run if it lasts longer than `DURATION`.
      - name: execution-timeout
        type: duration
        description: |
          Fail a WorkflowExecution if it lasts longer than `DURATION`.
          This time-out includes retries and ContinueAsNew tasks.
      - name: task-timeout
        type: duration
        description: |
          Fail a Workflow Task if it lasts longer than `DURATION`.
          This is the Start-to-close timeout for a Workflow Task.
        default: 10s
      - name: search-attribute
        type: string[]
        description: |
          Search Attribute in `KEY=VALUE` format.
          Keys must be identifiers, and values must be JSON values.
          For example: 'YourKey={"your": "value"}'.
          Can be passed multiple times.
      - name: headers
        type: string[]
        description: |
          Temporal workflow headers in 'KEY=VALUE' format.
          Keys must be identifiers, and values must be JSON values.
          May be passed multiple times to set multiple Temporal headers.
          Note: These are workflow headers, not gRPC headers.
      - name: memo
        type: string[]
        description: |
          Memo using 'KEY="VALUE"' pairs.
          Use JSON values.
      - name: static-summary
        type: string
        experimental: true
        description: |
          Static Workflow summary for human consumption in UIs.
          Uses Temporal Markdown formatting, should be a single line.
      - name: static-details
        type: string
        experimental: true
        description: |
          Static Workflow details for human consumption in UIs.
          Uses Temporal Markdown formatting, may be multiple lines.
      - name: priority-key
        type: int
        description: |
          Priority key (1-5, lower numbers = higher priority).
          Tasks in a queue should be processed in close-to-priority-order.
          Default is 3 when not specified.
      - name: fairness-key
        type: string
        description: |
          Fairness key (max 64 bytes) for proportional task dispatch.
          Tasks with same key share capacity based on their weight.
      - name: fairness-weight
        type: float
        description: |
          Weight [0.001-1000] for this fairness key.
          Keys are dispatched proportionally to their weights.

  - name: workflow-start
    options:
      - name: cron
        type: string
        description: Cron schedule for the Workflow.
        deprecated: Use Schedules instead.
      - name: fail-existing
        type: bool
        description: Fail if the Workflow already exists.
      - name: start-delay
        type: duration
        description: |
          Delay before starting the Workflow Execution.
          Can't be used with cron schedules.
          If the Workflow receives a signal or update prior to this time, the Workflow
          Execution starts immediately.
      - name: id-reuse-policy
        type: string-enum
        description: Re-use policy for the Workflow ID in new Workflow Executions.
        enum-values:
          - AllowDuplicate
          - AllowDuplicateFailedOnly
          - RejectDuplicate
          - TerminateIfRunning
      - name: id-conflict-policy
        type: string-enum
        description: |
          Determines how to resolve a conflict when spawning a new Workflow Execution
          with a particular Workflow Id used by an existing Open Workflow Execution.
        enum-values:
          - Fail
          - UseExisting
          - TerminateExisting

  - name: payload-input
    options:
      - name: input
        type: string[]
        short: i
        description: |
          Input value.
          Use JSON content or set --input-meta to override.
          Can't be combined with --input-file.
          Can be passed multiple times to pass multiple arguments.
      - name: input-file
        type: string[]
        description: |
          A path or paths for input file(s).
          Use JSON content or set --input-meta to override.
          Can't be combined with --input.
          Can be passed multiple times to pass multiple arguments.
      - name: input-meta
        type: string[]
        description: |
          Input payload metadata as a `KEY=VALUE` pair.
          When the KEY is "encoding", this overrides the default ("json/plain").
          Can be passed multiple times.
          Repeated metadata keys are applied to the corresponding inputs in the provided order.
      - name: input-base64
        type: bool
        description: |
          Assume inputs are base64-encoded and attempt to decode them.

  - name: update-starting
    options:
      - name: name
        type: string
        description: Handler method name.
        required: true
        aliases:
          - type
      - name: first-execution-run-id
        type: string
        description: |
          Parent Run ID.
          The update is sent to the last Workflow Execution in the chain started
          with this Run ID.
      - name: workflow-id
        type: string
        short: w
        description: Workflow ID.
        required: true
      - name: update-id
        type: string
        description: |
          Update ID.
          If unset, defaults to a UUID.
      - name: run-id
        type: string
        short: r
        description: |
          Run ID.
          If unset, looks for an Update against the currently-running Workflow Execution.
      - name: headers
        type: string[]
        description: |
          Temporal workflow headers in 'KEY=VALUE' format.
          Keys must be identifiers, and values must be JSON values.
          May be passed multiple times to set multiple Temporal headers.
          Note: These are workflow headers, not gRPC headers.

  - name: update-targeting
    options:
      - name: workflow-id
        short: w
        type: string
        description: Workflow ID.
        required: true
      - name: update-id
        type: string
        description: |
          Update ID.
          Must be unique per Workflow Execution.
        required: true
      - name: run-id
        type: string
        short: r
        description: |
          Run ID.
          If unset, updates the currently-running Workflow Execution.

  - name: nexus-endpoint-identity
    options:
      - name: name
        type: string
        description: Endpoint name.
        required: true

  - name: nexus-endpoint-config
    options:
      - name: description
        type: string
        description: |
          Nexus Endpoint description.
          You may use Markdown formatting in the Nexus Endpoint description.
      - name: description-file
        type: string
        description: |
          Path to the Nexus Endpoint description file.
          The contents of the description file may use Markdown formatting.
      - name: target-namespace
        type: string
        description: Namespace where a handler Worker polls for Nexus tasks.
      - name: target-task-queue
        type: string
        description: Task Queue that a handler Worker polls for Nexus tasks.
      - name: target-url
        type: string
        experimental: true
        description: |
          An external Nexus Endpoint that receives forwarded Nexus requests.
          May be used as an alternative to `--target-namespace` and
          `--target-task-queue`.

  - name: query-modifiers
    options:
      - name: reject-condition
        type: string-enum
        description: |
          Optional flag for rejecting Queries based on Workflow state.
        enum-values:
          - not_open
          - not_completed_cleanly
      - name: headers
        type: string[]
        description: |
          Temporal workflow headers in 'KEY=VALUE' format.
          Keys must be identifiers, and values must be JSON values.
          May be passed multiple times to set multiple Temporal headers.
          Note: These are workflow headers, not gRPC headers.

  - name: workflow-update-options
    options:
      - name: versioning-override-behavior
        type: string-enum
        description: |
          Override the versioning behavior of a Workflow.
        required: true
        enum-values:
          - pinned
          - auto_upgrade
      - name: versioning-override-deployment-name
        type: string
        description:
          When overriding to a `pinned` behavior, specifies the Deployment Name of the
          version to target.
      - name: versioning-override-build-id
        type: string
        description:
          When overriding to a `pinned` behavior, specifies the Build ID of the
          version to target.

  - name: activity-reference
    options:
      - name: activity-id
        type: string
        short: a
        description: Activity ID.
        required: true
      - name: run-id
        type: string
        short: r
        description: |
          Activity Run ID.
          If not set, targets the latest run.

  - name: activity-start
    options:
      - name: activity-id
        type: string
        short: a
        description: Activity ID.
        required: true
      - name: type
        type: string
        description: Activity Type name.
        required: true
      - name: task-queue
        type: string
        description: Activity task queue.
        required: true
        short: t
      - name: schedule-to-close-timeout
        type: duration
        description: |
          Maximum time for the Activity Execution, including
          all retries. Either this or "start-to-close-timeout"
          is required.
      - name: schedule-to-start-timeout
        type: duration
        description: |
          Maximum time an Activity task can stay in a task
          queue before a Worker picks it up. On expiry it
          results in a non-retryable failure and no further
          attempts are scheduled.
      - name: start-to-close-timeout
        type: duration
        description: |
          Maximum time for a single Activity attempt.
          On expiry a new attempt may be scheduled if permitted
          by the retry policy and schedule-to-close timeout.
          Either this or "schedule-to-close-timeout"
          is required.
      - name: heartbeat-timeout
        type: duration
        description: |
          Maximum time between successful Worker heartbeats.
          On expiry the current activity attempt fails.
      - name: retry-initial-interval
        type: duration
        description: |
          Interval of the first retry.
          If "retry-backoff-coefficient" is 1.0, it is used
          for all retries.
      - name: retry-maximum-interval
        type: duration
        description: |
          Maximum interval between retries.
      - name: retry-backoff-coefficient
        type: float
        description: |
          Coefficient for calculating the next retry interval.
          Must be 1 or larger.
      - name: retry-maximum-attempts
        type: int
        description: |
          Maximum number of attempts.
          Setting to 1 disables retries.
          Setting to 0 means unlimited attempts.
      - name: id-reuse-policy
        type: string-enum
        description: |
          Policy for handling activity start when an Activity
          with the same ID exists and has completed.
        enum-values:
          - AllowDuplicate
          - AllowDuplicateFailedOnly
          - RejectDuplicate
      - name: id-conflict-policy
        type: string-enum
        description: |
          Policy for handling activity start when an
          Activity with the same ID is currently running.
        enum-values:
          - Fail
          - UseExisting
      - name: search-attribute
        type: string[]
        description: |
          Search Attribute in `KEY=VALUE` format.
          Keys must be identifiers, and values must be
          JSON values.
          Can be passed multiple times.
          See https://docs.temporal.io/visibility.
      - name: headers
        type: string[]
        description: |
          Temporal activity headers in 'KEY=VALUE' format.
          Keys must be identifiers, and values must be
          JSON values.
          May be passed multiple times.
      - name: static-summary
        type: string
        experimental: true
        description: |
          Static Activity summary for human consumption in UIs.
          Uses standard Markdown formatting excluding images, HTML, and script tags.
      - name: static-details
        type: string
        experimental: true
        description: |
          Static Activity details for human consumption in UIs.
          Uses standard Markdown formatting excluding images, HTML, and script tags.
      - name: priority-key
        type: int
        description: |
          Priority key (1-5, lower = higher priority).
          Default is 3 when not specified.
      - name: fairness-key
        type: string
        description: |
          Fairness key (max 64 bytes) for proportional task
          dispatch.
      - name: fairness-weight
        type: float
        description: |
          Weight [0.001-1000] for this fairness key.