@proompteng/temporal-bun-sdk 0.1.0

package/dist/src/proto/temporal/api/taskqueue/v1/message_pb.d.ts

@@ -0,0 +1,757 @@
+import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt";
+import type { BuildIdTaskReachability, TaskQueueKind, TaskReachability } from "../../enums/v1/task_queue_pb.js";
+import type { WorkerVersionCapabilities } from "../../common/v1/message_pb.js";
+import type { WorkerDeploymentOptions, WorkerDeploymentVersion } from "../../deployment/v1/message_pb.js";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file temporal/api/taskqueue/v1/message.proto.
+ */
+export declare const file_temporal_api_taskqueue_v1_message: GenFile;
+/**
+ * See https://docs.temporal.io/docs/concepts/task-queues/
+ *
+ * @generated from message temporal.api.taskqueue.v1.TaskQueue
+ */
+export type TaskQueue = Message<"temporal.api.taskqueue.v1.TaskQueue"> & {
+    /**
+     * @generated from field: string name = 1;
+     */
+    name: string;
+    /**
+     * Default: TASK_QUEUE_KIND_NORMAL.
+     *
+     * @generated from field: temporal.api.enums.v1.TaskQueueKind kind = 2;
+     */
+    kind: TaskQueueKind;
+    /**
+     * Iff kind == TASK_QUEUE_KIND_STICKY, then this field contains the name of
+     * the normal task queue that the sticky worker is running on.
+     *
+     * @generated from field: string normal_name = 3;
+     */
+    normalName: string;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueue.
+ * Use `create(TaskQueueSchema)` to create a new message.
+ */
+export declare const TaskQueueSchema: GenMessage<TaskQueue>;
+/**
+ * Only applies to activity task queues
+ *
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueMetadata
+ */
+export type TaskQueueMetadata = Message<"temporal.api.taskqueue.v1.TaskQueueMetadata"> & {
+    /**
+     * Allows throttling dispatch of tasks from this queue
+     *
+     * @generated from field: google.protobuf.DoubleValue max_tasks_per_second = 1;
+     */
+    maxTasksPerSecond?: number;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueMetadata.
+ * Use `create(TaskQueueMetadataSchema)` to create a new message.
+ */
+export declare const TaskQueueMetadataSchema: GenMessage<TaskQueueMetadata>;
+/**
+ * Experimental. Worker Deployments are experimental and might significantly change in the future.
+ *
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueVersioningInfo
+ */
+export type TaskQueueVersioningInfo = Message<"temporal.api.taskqueue.v1.TaskQueueVersioningInfo"> & {
+    /**
+     * Specifies which Deployment Version should receive new workflow executions and tasks of
+     * existing unversioned or AutoUpgrade workflows.
+     * Nil value represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.)
+     * Note: Current Version is overridden by the Ramping Version for a portion of traffic when ramp percentage
+     * is non-zero (see `ramping_deployment_version` and `ramping_version_percentage`).
+     *
+     * @generated from field: temporal.api.deployment.v1.WorkerDeploymentVersion current_deployment_version = 7;
+     */
+    currentDeploymentVersion?: WorkerDeploymentVersion;
+    /**
+     * Deprecated. Use `current_deployment_version`.
+     *
+     * @generated from field: string current_version = 1 [deprecated = true];
+     * @deprecated
+     */
+    currentVersion: string;
+    /**
+     * When ramp percentage is non-zero, that portion of traffic is shifted from the Current Version to the Ramping Version.
+     * Must always be different from `current_deployment_version` unless both are nil.
+     * Nil value represents all the unversioned workers (those with `UNVERSIONED` (or unspecified) `WorkerVersioningMode`.)
+     * Note that it is possible to ramp from one Version to another Version, or from unversioned
+     * workers to a particular Version, or from a particular Version to unversioned workers.
+     *
+     * @generated from field: temporal.api.deployment.v1.WorkerDeploymentVersion ramping_deployment_version = 9;
+     */
+    rampingDeploymentVersion?: WorkerDeploymentVersion;
+    /**
+     * Deprecated. Use `ramping_deployment_version`.
+     *
+     * @generated from field: string ramping_version = 2 [deprecated = true];
+     * @deprecated
+     */
+    rampingVersion: string;
+    /**
+     * Percentage of tasks that are routed to the Ramping Version instead of the Current Version.
+     * Valid range: [0, 100]. A 100% value means the Ramping Version is receiving full traffic but
+     * not yet "promoted" to be the Current Version, likely due to pending validations.
+     * A 0% value means the Ramping Version is receiving no traffic.
+     *
+     * @generated from field: float ramping_version_percentage = 3;
+     */
+    rampingVersionPercentage: number;
+    /**
+     * Last time versioning information of this Task Queue changed.
+     *
+     * @generated from field: google.protobuf.Timestamp update_time = 4;
+     */
+    updateTime?: Timestamp;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueVersioningInfo.
+ * Use `create(TaskQueueVersioningInfoSchema)` to create a new message.
+ */
+export declare const TaskQueueVersioningInfoSchema: GenMessage<TaskQueueVersioningInfo>;
+/**
+ * Used for specifying versions the caller is interested in.
+ *
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueVersionSelection
+ */
+export type TaskQueueVersionSelection = Message<"temporal.api.taskqueue.v1.TaskQueueVersionSelection"> & {
+    /**
+     * Include specific Build IDs.
+     *
+     * @generated from field: repeated string build_ids = 1;
+     */
+    buildIds: string[];
+    /**
+     * Include the unversioned queue.
+     *
+     * @generated from field: bool unversioned = 2;
+     */
+    unversioned: boolean;
+    /**
+     * Include all active versions. A version is considered active if, in the last few minutes,
+     * it has had new tasks or polls, or it has been the subject of certain task queue API calls.
+     *
+     * @generated from field: bool all_active = 3;
+     */
+    allActive: boolean;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueVersionSelection.
+ * Use `create(TaskQueueVersionSelectionSchema)` to create a new message.
+ */
+export declare const TaskQueueVersionSelectionSchema: GenMessage<TaskQueueVersionSelection>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueVersionInfo
+ */
+export type TaskQueueVersionInfo = Message<"temporal.api.taskqueue.v1.TaskQueueVersionInfo"> & {
+    /**
+     * Task Queue info per Task Type. Key is the numerical value of the temporal.api.enums.v1.TaskQueueType enum.
+     *
+     * @generated from field: map<int32, temporal.api.taskqueue.v1.TaskQueueTypeInfo> types_info = 1;
+     */
+    typesInfo: {
+        [key: number]: TaskQueueTypeInfo;
+    };
+    /**
+     * Task Reachability is eventually consistent; there may be a delay until it converges to the most
+     * accurate value but it is designed in a way to take the more conservative side until it converges.
+     * For example REACHABLE is more conservative than CLOSED_WORKFLOWS_ONLY.
+     *
+     * Note: future activities who inherit their workflow's Build ID but not its Task Queue will not be
+     * accounted for reachability as server cannot know if they'll happen as they do not use
+     * assignment rules of their Task Queue. Same goes for Child Workflows or Continue-As-New Workflows
+     * who inherit the parent/previous workflow's Build ID but not its Task Queue. In those cases, make
+     * sure to query reachability for the parent/previous workflow's Task Queue as well.
+     *
+     * @generated from field: temporal.api.enums.v1.BuildIdTaskReachability task_reachability = 2;
+     */
+    taskReachability: BuildIdTaskReachability;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueVersionInfo.
+ * Use `create(TaskQueueVersionInfoSchema)` to create a new message.
+ */
+export declare const TaskQueueVersionInfoSchema: GenMessage<TaskQueueVersionInfo>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueTypeInfo
+ */
+export type TaskQueueTypeInfo = Message<"temporal.api.taskqueue.v1.TaskQueueTypeInfo"> & {
+    /**
+     * Unversioned workers (with `useVersioning=false`) are reported in unversioned result even if they set a Build ID.
+     *
+     * @generated from field: repeated temporal.api.taskqueue.v1.PollerInfo pollers = 1;
+     */
+    pollers: PollerInfo[];
+    /**
+     * @generated from field: temporal.api.taskqueue.v1.TaskQueueStats stats = 2;
+     */
+    stats?: TaskQueueStats;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueTypeInfo.
+ * Use `create(TaskQueueTypeInfoSchema)` to create a new message.
+ */
+export declare const TaskQueueTypeInfoSchema: GenMessage<TaskQueueTypeInfo>;
+/**
+ * TaskQueueStats contains statistics about task queue backlog and activity.
+ *
+ * For workflow task queue type, this result is partial because tasks sent to sticky queues are not included. Read
+ * comments above each metric to understand the impact of sticky queue exclusion on that metric accuracy.
+ *
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueStats
+ */
+export type TaskQueueStats = Message<"temporal.api.taskqueue.v1.TaskQueueStats"> & {
+    /**
+     * The approximate number of tasks backlogged in this task queue. May count expired tasks but eventually
+     * converges to the right value. Can be relied upon for scaling decisions.
+     *
+     * Special note for workflow task queue type: this metric does not count sticky queue tasks. However, because
+     * those tasks only remain valid for a few seconds, the inaccuracy becomes less significant as the backlog size
+     * grows.
+     *
+     * @generated from field: int64 approximate_backlog_count = 1;
+     */
+    approximateBacklogCount: bigint;
+    /**
+     * Approximate age of the oldest task in the backlog based on the creation time of the task at the head of
+     * the queue. Can be relied upon for scaling decisions.
+     *
+     * Special note for workflow task queue type: this metric does not count sticky queue tasks. However, because
+     * those tasks only remain valid for a few seconds, they should not affect the result when backlog is older than
+     * few seconds.
+     *
+     * @generated from field: google.protobuf.Duration approximate_backlog_age = 2;
+     */
+    approximateBacklogAge?: Duration;
+    /**
+     * The approximate tasks per second added to the task queue, averaging the last 30 seconds. These includes tasks
+     * whether or not they were added to/dispatched from the backlog or they were dispatched immediately without going
+     * to the backlog (sync-matched).
+     *
+     * The difference between `tasks_add_rate` and `tasks_dispatch_rate` is a reliable metric for the rate at which
+     * backlog grows/shrinks.
+     *
+     * Note: the actual tasks delivered to the workers may significantly be higher than the numbers reported by
+     * tasks_add_rate, because:
+     * - Tasks can be sent to workers without going to the task queue. This is called Eager dispatch. Eager dispatch is
+     *   enable for activities by default in the latest SDKs.
+     * - Tasks going to Sticky queue are not accounted for. Note that, typically, only the first workflow task of each
+     *   workflow goes to a normal queue, and the rest workflow tasks go to the Sticky queue associated with a specific
+     *   worker instance.
+     *
+     * @generated from field: float tasks_add_rate = 3;
+     */
+    tasksAddRate: number;
+    /**
+     * The approximate tasks per second dispatched from the task queue, averaging the last 30 seconds. These includes
+     * tasks whether or not they were added to/dispatched from the backlog or they were dispatched immediately without
+     * going to the backlog (sync-matched).
+     *
+     * The difference between `tasks_add_rate` and `tasks_dispatch_rate` is a reliable metric for the rate at which
+     * backlog grows/shrinks.
+     *
+     * Note: the actual tasks delivered to the workers may significantly be higher than the numbers reported by
+     * tasks_dispatch_rate, because:
+     * - Tasks can be sent to workers without going to the task queue. This is called Eager dispatch. Eager dispatch is
+     *   enable for activities by default in the latest SDKs.
+     * - Tasks going to Sticky queue are not accounted for. Note that, typically, only the first workflow task of each
+     *   workflow goes to a normal queue, and the rest workflow tasks go to the Sticky queue associated with a specific
+     *   worker instance.
+     *
+     * @generated from field: float tasks_dispatch_rate = 4;
+     */
+    tasksDispatchRate: number;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueStats.
+ * Use `create(TaskQueueStatsSchema)` to create a new message.
+ */
+export declare const TaskQueueStatsSchema: GenMessage<TaskQueueStats>;
+/**
+ * Deprecated. Use `InternalTaskQueueStatus`. This is kept until `DescribeTaskQueue` supports legacy behavior.
+ *
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueStatus
+ */
+export type TaskQueueStatus = Message<"temporal.api.taskqueue.v1.TaskQueueStatus"> & {
+    /**
+     * @generated from field: int64 backlog_count_hint = 1;
+     */
+    backlogCountHint: bigint;
+    /**
+     * @generated from field: int64 read_level = 2;
+     */
+    readLevel: bigint;
+    /**
+     * @generated from field: int64 ack_level = 3;
+     */
+    ackLevel: bigint;
+    /**
+     * @generated from field: double rate_per_second = 4;
+     */
+    ratePerSecond: number;
+    /**
+     * @generated from field: temporal.api.taskqueue.v1.TaskIdBlock task_id_block = 5;
+     */
+    taskIdBlock?: TaskIdBlock;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueStatus.
+ * Use `create(TaskQueueStatusSchema)` to create a new message.
+ */
+export declare const TaskQueueStatusSchema: GenMessage<TaskQueueStatus>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.TaskIdBlock
+ */
+export type TaskIdBlock = Message<"temporal.api.taskqueue.v1.TaskIdBlock"> & {
+    /**
+     * @generated from field: int64 start_id = 1;
+     */
+    startId: bigint;
+    /**
+     * @generated from field: int64 end_id = 2;
+     */
+    endId: bigint;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskIdBlock.
+ * Use `create(TaskIdBlockSchema)` to create a new message.
+ */
+export declare const TaskIdBlockSchema: GenMessage<TaskIdBlock>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.TaskQueuePartitionMetadata
+ */
+export type TaskQueuePartitionMetadata = Message<"temporal.api.taskqueue.v1.TaskQueuePartitionMetadata"> & {
+    /**
+     * @generated from field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from field: string owner_host_name = 2;
+     */
+    ownerHostName: string;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueuePartitionMetadata.
+ * Use `create(TaskQueuePartitionMetadataSchema)` to create a new message.
+ */
+export declare const TaskQueuePartitionMetadataSchema: GenMessage<TaskQueuePartitionMetadata>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.PollerInfo
+ */
+export type PollerInfo = Message<"temporal.api.taskqueue.v1.PollerInfo"> & {
+    /**
+     * @generated from field: google.protobuf.Timestamp last_access_time = 1;
+     */
+    lastAccessTime?: Timestamp;
+    /**
+     * @generated from field: string identity = 2;
+     */
+    identity: string;
+    /**
+     * @generated from field: double rate_per_second = 3;
+     */
+    ratePerSecond: number;
+    /**
+     * If a worker has opted into the worker versioning feature while polling, its capabilities will
+     * appear here.
+     * Deprecated. Replaced by deployment_options.
+     *
+     * @generated from field: temporal.api.common.v1.WorkerVersionCapabilities worker_version_capabilities = 4 [deprecated = true];
+     * @deprecated
+     */
+    workerVersionCapabilities?: WorkerVersionCapabilities;
+    /**
+     * Worker deployment options that SDK sent to server.
+     *
+     * @generated from field: temporal.api.deployment.v1.WorkerDeploymentOptions deployment_options = 5;
+     */
+    deploymentOptions?: WorkerDeploymentOptions;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.PollerInfo.
+ * Use `create(PollerInfoSchema)` to create a new message.
+ */
+export declare const PollerInfoSchema: GenMessage<PollerInfo>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.StickyExecutionAttributes
+ */
+export type StickyExecutionAttributes = Message<"temporal.api.taskqueue.v1.StickyExecutionAttributes"> & {
+    /**
+     * @generated from field: temporal.api.taskqueue.v1.TaskQueue worker_task_queue = 1;
+     */
+    workerTaskQueue?: TaskQueue;
+    /**
+     * (-- api-linter: core::0140::prepositions=disabled
+     *     aip.dev/not-precedent: "to" is used to indicate interval. --)
+     *
+     * @generated from field: google.protobuf.Duration schedule_to_start_timeout = 2;
+     */
+    scheduleToStartTimeout?: Duration;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.StickyExecutionAttributes.
+ * Use `create(StickyExecutionAttributesSchema)` to create a new message.
+ */
+export declare const StickyExecutionAttributesSchema: GenMessage<StickyExecutionAttributes>;
+/**
+ * Used by the worker versioning APIs, represents an unordered set of one or more versions which are
+ * considered to be compatible with each other. Currently the versions are always worker build IDs.
+ *
+ * @generated from message temporal.api.taskqueue.v1.CompatibleVersionSet
+ */
+export type CompatibleVersionSet = Message<"temporal.api.taskqueue.v1.CompatibleVersionSet"> & {
+    /**
+     * All the compatible versions, unordered, except for the last element, which is considered the set "default".
+     *
+     * @generated from field: repeated string build_ids = 1;
+     */
+    buildIds: string[];
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.CompatibleVersionSet.
+ * Use `create(CompatibleVersionSetSchema)` to create a new message.
+ */
+export declare const CompatibleVersionSetSchema: GenMessage<CompatibleVersionSet>;
+/**
+ * Reachability of tasks for a worker on a single task queue.
+ *
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueReachability
+ */
+export type TaskQueueReachability = Message<"temporal.api.taskqueue.v1.TaskQueueReachability"> & {
+    /**
+     * @generated from field: string task_queue = 1;
+     */
+    taskQueue: string;
+    /**
+     * Task reachability for a worker in a single task queue.
+     * See the TaskReachability docstring for information about each enum variant.
+     * If reachability is empty, this worker is considered unreachable in this task queue.
+     *
+     * @generated from field: repeated temporal.api.enums.v1.TaskReachability reachability = 2;
+     */
+    reachability: TaskReachability[];
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueReachability.
+ * Use `create(TaskQueueReachabilitySchema)` to create a new message.
+ */
+export declare const TaskQueueReachabilitySchema: GenMessage<TaskQueueReachability>;
+/**
+ * Reachability of tasks for a worker by build id, in one or more task queues.
+ *
+ * @generated from message temporal.api.taskqueue.v1.BuildIdReachability
+ */
+export type BuildIdReachability = Message<"temporal.api.taskqueue.v1.BuildIdReachability"> & {
+    /**
+     * A build id or empty if unversioned.
+     *
+     * @generated from field: string build_id = 1;
+     */
+    buildId: string;
+    /**
+     * Reachability per task queue.
+     *
+     * @generated from field: repeated temporal.api.taskqueue.v1.TaskQueueReachability task_queue_reachability = 2;
+     */
+    taskQueueReachability: TaskQueueReachability[];
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.BuildIdReachability.
+ * Use `create(BuildIdReachabilitySchema)` to create a new message.
+ */
+export declare const BuildIdReachabilitySchema: GenMessage<BuildIdReachability>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.RampByPercentage
+ */
+export type RampByPercentage = Message<"temporal.api.taskqueue.v1.RampByPercentage"> & {
+    /**
+     * Acceptable range is [0,100).
+     *
+     * @generated from field: float ramp_percentage = 1;
+     */
+    rampPercentage: number;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.RampByPercentage.
+ * Use `create(RampByPercentageSchema)` to create a new message.
+ */
+export declare const RampByPercentageSchema: GenMessage<RampByPercentage>;
+/**
+ * Assignment rules are applied to *new* Workflow and Activity executions at
+ * schedule time to assign them to a Build ID.
+ *
+ * Assignment rules will not be used in the following cases:
+ *    - Child Workflows or Continue-As-New Executions who inherit their
+ *      parent/previous Workflow's assigned Build ID (by setting the
+ *      `inherit_build_id` flag - default behavior in SDKs when the same Task Queue
+ *      is used.)
+ *    - An Activity that inherits the assigned Build ID of its Workflow (by
+ *      setting the `use_workflow_build_id` flag - default behavior in SDKs
+ *      when the same Task Queue is used.)
+ *
+ * In absence of (applicable) redirect rules (`CompatibleBuildIdRedirectRule`s)
+ * the task will be dispatched to Workers of the Build ID determined by the
+ * assignment rules (or inherited). Otherwise, the final Build ID will be
+ * determined by the redirect rules.
+ *
+ * Once a Workflow completes its first Workflow Task in a particular Build ID it
+ * stays in that Build ID regardless of changes to assignment rules. Redirect
+ * rules can be used to move the workflow to another compatible Build ID.
+ *
+ * When using Worker Versioning on a Task Queue, in the steady state,
+ * there should typically be a single assignment rule to send all new executions
+ * to the latest Build ID. Existence of at least one such "unconditional"
+ * rule at all times is enforces by the system, unless the `force` flag is used
+ * by the user when replacing/deleting these rules (for exceptional cases).
+ *
+ * During a deployment, one or more additional rules can be added to assign a
+ * subset of the tasks to a new Build ID based on a "ramp percentage".
+ *
+ * When there are multiple assignment rules for a Task Queue, the rules are
+ * evaluated in order, starting from index 0. The first applicable rule will be
+ * applied and the rest will be ignored.
+ *
+ * In the event that no assignment rule is applicable on a task (or the Task
+ * Queue is simply not versioned), the tasks will be dispatched to an
+ * unversioned Worker.
+ *
+ * @generated from message temporal.api.taskqueue.v1.BuildIdAssignmentRule
+ */
+export type BuildIdAssignmentRule = Message<"temporal.api.taskqueue.v1.BuildIdAssignmentRule"> & {
+    /**
+     * @generated from field: string target_build_id = 1;
+     */
+    targetBuildId: string;
+    /**
+     * If a ramp is provided, this rule will be applied only to a sample of
+     * tasks according to the provided percentage.
+     * This option can be used only on "terminal" Build IDs (the ones not used
+     * as source in any redirect rules).
+     *
+     * @generated from oneof temporal.api.taskqueue.v1.BuildIdAssignmentRule.ramp
+     */
+    ramp: {
+        /**
+         * This ramp is useful for gradual Blue/Green deployments (and similar)
+         * where you want to send a certain portion of the traffic to the target
+         * Build ID.
+         *
+         * @generated from field: temporal.api.taskqueue.v1.RampByPercentage percentage_ramp = 3;
+         */
+        value: RampByPercentage;
+        case: "percentageRamp";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.BuildIdAssignmentRule.
+ * Use `create(BuildIdAssignmentRuleSchema)` to create a new message.
+ */
+export declare const BuildIdAssignmentRuleSchema: GenMessage<BuildIdAssignmentRule>;
+/**
+ * These rules apply to tasks assigned to a particular Build ID
+ * (`source_build_id`) to redirect them to another *compatible* Build ID
+ * (`target_build_id`).
+ *
+ * It is user's responsibility to ensure that the target Build ID is compatible
+ * with the source Build ID (e.g. by using the Patching API).
+ *
+ * Most deployments are not expected to need these rules, however following
+ * situations can greatly benefit from redirects:
+ *  - Need to move long-running Workflow Executions from an old Build ID to a
+ *    newer one.
+ *  - Need to hotfix some broken or stuck Workflow Executions.
+ *
+ * In steady state, redirect rules are beneficial when dealing with old
+ * Executions ran on now-decommissioned Build IDs:
+ *  - To redirecting the Workflow Queries to the current (compatible) Build ID.
+ *  - To be able to Reset an old Execution so it can run on the current
+ *    (compatible) Build ID.
+ *
+ * Redirect rules can be chained.
+ *
+ * @generated from message temporal.api.taskqueue.v1.CompatibleBuildIdRedirectRule
+ */
+export type CompatibleBuildIdRedirectRule = Message<"temporal.api.taskqueue.v1.CompatibleBuildIdRedirectRule"> & {
+    /**
+     * @generated from field: string source_build_id = 1;
+     */
+    sourceBuildId: string;
+    /**
+     * Target Build ID must be compatible with the Source Build ID; that is it
+     * must be able to process event histories made by the Source Build ID by
+     * using [Patching](https://docs.temporal.io/workflows#patching) or other
+     * means.
+     *
+     * @generated from field: string target_build_id = 2;
+     */
+    targetBuildId: string;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.CompatibleBuildIdRedirectRule.
+ * Use `create(CompatibleBuildIdRedirectRuleSchema)` to create a new message.
+ */
+export declare const CompatibleBuildIdRedirectRuleSchema: GenMessage<CompatibleBuildIdRedirectRule>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.TimestampedBuildIdAssignmentRule
+ */
+export type TimestampedBuildIdAssignmentRule = Message<"temporal.api.taskqueue.v1.TimestampedBuildIdAssignmentRule"> & {
+    /**
+     * @generated from field: temporal.api.taskqueue.v1.BuildIdAssignmentRule rule = 1;
+     */
+    rule?: BuildIdAssignmentRule;
+    /**
+     * @generated from field: google.protobuf.Timestamp create_time = 2;
+     */
+    createTime?: Timestamp;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TimestampedBuildIdAssignmentRule.
+ * Use `create(TimestampedBuildIdAssignmentRuleSchema)` to create a new message.
+ */
+export declare const TimestampedBuildIdAssignmentRuleSchema: GenMessage<TimestampedBuildIdAssignmentRule>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.TimestampedCompatibleBuildIdRedirectRule
+ */
+export type TimestampedCompatibleBuildIdRedirectRule = Message<"temporal.api.taskqueue.v1.TimestampedCompatibleBuildIdRedirectRule"> & {
+    /**
+     * @generated from field: temporal.api.taskqueue.v1.CompatibleBuildIdRedirectRule rule = 1;
+     */
+    rule?: CompatibleBuildIdRedirectRule;
+    /**
+     * @generated from field: google.protobuf.Timestamp create_time = 2;
+     */
+    createTime?: Timestamp;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TimestampedCompatibleBuildIdRedirectRule.
+ * Use `create(TimestampedCompatibleBuildIdRedirectRuleSchema)` to create a new message.
+ */
+export declare const TimestampedCompatibleBuildIdRedirectRuleSchema: GenMessage<TimestampedCompatibleBuildIdRedirectRule>;
+/**
+ * Attached to task responses to give hints to the SDK about how it may adjust its number of
+ * pollers.
+ *
+ * @generated from message temporal.api.taskqueue.v1.PollerScalingDecision
+ */
+export type PollerScalingDecision = Message<"temporal.api.taskqueue.v1.PollerScalingDecision"> & {
+    /**
+     * How many poll requests to suggest should be added or removed, if any. As of now, server only
+     * scales up or down by 1. However, SDKs should allow for other values (while staying within
+     * defined min/max).
+     *
+     * The SDK is free to ignore this suggestion, EX: making more polls would not make sense because
+     * all slots are already occupied.
+     *
+     * @generated from field: int32 poll_request_delta_suggestion = 1;
+     */
+    pollRequestDeltaSuggestion: number;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.PollerScalingDecision.
+ * Use `create(PollerScalingDecisionSchema)` to create a new message.
+ */
+export declare const PollerScalingDecisionSchema: GenMessage<PollerScalingDecision>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.RateLimit
+ */
+export type RateLimit = Message<"temporal.api.taskqueue.v1.RateLimit"> & {
+    /**
+     * Zero is a valid rate limit.
+     *
+     * @generated from field: float requests_per_second = 1;
+     */
+    requestsPerSecond: number;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.RateLimit.
+ * Use `create(RateLimitSchema)` to create a new message.
+ */
+export declare const RateLimitSchema: GenMessage<RateLimit>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.ConfigMetadata
+ */
+export type ConfigMetadata = Message<"temporal.api.taskqueue.v1.ConfigMetadata"> & {
+    /**
+     * Reason for why the config was set.
+     *
+     * @generated from field: string reason = 1;
+     */
+    reason: string;
+    /**
+     * Identity of the last updater.
+     * Set by the request's identity field.
+     *
+     * @generated from field: string update_identity = 2;
+     */
+    updateIdentity: string;
+    /**
+     * Time of the last update.
+     *
+     * @generated from field: google.protobuf.Timestamp update_time = 3;
+     */
+    updateTime?: Timestamp;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.ConfigMetadata.
+ * Use `create(ConfigMetadataSchema)` to create a new message.
+ */
+export declare const ConfigMetadataSchema: GenMessage<ConfigMetadata>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.RateLimitConfig
+ */
+export type RateLimitConfig = Message<"temporal.api.taskqueue.v1.RateLimitConfig"> & {
+    /**
+     * @generated from field: temporal.api.taskqueue.v1.RateLimit rate_limit = 1;
+     */
+    rateLimit?: RateLimit;
+    /**
+     * @generated from field: temporal.api.taskqueue.v1.ConfigMetadata metadata = 2;
+     */
+    metadata?: ConfigMetadata;
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.RateLimitConfig.
+ * Use `create(RateLimitConfigSchema)` to create a new message.
+ */
+export declare const RateLimitConfigSchema: GenMessage<RateLimitConfig>;
+/**
+ * @generated from message temporal.api.taskqueue.v1.TaskQueueConfig
+ */
+export type TaskQueueConfig = Message<"temporal.api.taskqueue.v1.TaskQueueConfig"> & {
+    /**
+     * Unless modified, this is the system-defined rate limit.
+     *
+     * @generated from field: temporal.api.taskqueue.v1.RateLimitConfig queue_rate_limit = 1;
+     */
+    queueRateLimit?: RateLimitConfig;
+    /**
+     * If set, each individual fairness key will be limited to this rate, scaled by the weight of the fairness key.
+     *
+     * @generated from field: temporal.api.taskqueue.v1.RateLimitConfig fairness_keys_rate_limit_default = 2;
+     */
+    fairnessKeysRateLimitDefault?: RateLimitConfig;
+    /**
+     * If set, overrides the fairness weights for the corresponding fairness keys.
+     *
+     * @generated from field: map<string, float> fairness_weight_overrides = 3;
+     */
+    fairnessWeightOverrides: {
+        [key: string]: number;
+    };
+};
+/**
+ * Describes the message temporal.api.taskqueue.v1.TaskQueueConfig.
+ * Use `create(TaskQueueConfigSchema)` to create a new message.
+ */
+export declare const TaskQueueConfigSchema: GenMessage<TaskQueueConfig>;
+//# sourceMappingURL=message_pb.d.ts.map