temporal

type Activity struct {
	Options *ActivityOptions `protobuf:"bytes,1,opt,name=options,proto3" json:"options,omitempty"`
	// contains filtered or unexported fields
}

type ActivityOptions struct {

	// The task queue that the activity needs to be scheduled on.
	//
	// See https://docs.temporal.io/tasks#task-queue.
	// Optional: default = the workflow's task queue.
	TaskQueue string `protobuf:"bytes,1,opt,name=task_queue,json=taskQueue,proto3" json:"task_queue,omitempty"`
	// The maximum amount of time allowed for the overall Activity Execution,
	// from when the first Activity Task is scheduled to when the last Activity
	// Task, in the chain of Activity Tasks that make up the Activity Execution
	// (including retries), reaches a Closed status.
	//
	// An Activity Execution must have either this timeout (Schedule-To-Close)
	// or [StartToCloseTimeout] set. By default, an Activity Execution Retry
	// Policy dictates that retries will occur for up to 10 years. This timeout
	// can be used to control the overall duration of an Activity Execution in
	// the face of failures (repeated Activity Task Executions), without
	// altering the Maximum Attempts field of the Retry Policy.
	//
	// See https://docs.temporal.io/activities#schedule-to-close-timeout.
	// Optional: default = unlimited.
	ScheduleToCloseTimeout *durationpb.Duration `` /* 131-byte string literal not displayed */
	// The maximum amount of time that is allowed from when an Activity Task
	// is scheduled (that is, placed in a Task Queue) to when a Worker starts
	// (that is, picks up from the Task Queue) that Activity Task. In other
	// words, it's a limit for how long an Activity Task can be enqueued.
	//
	// If this timeout is used, we recommend setting this timeout to the
	// maximum time a Workflow Execution is willing to wait for an Activity
	// Execution in the presence of all possible Worker outages, and have a
	// concrete plan in place to reroute Activity Tasks to a different Task
	// Queue. This timeout does not trigger any retries regardless of the Retry
	// Policy, as a retry would place the Activity Task back into the same Task
	// Queue. We do not recommend using this timeout unless you know what you
	// are doing.
	//
	// See https://docs.temporal.io/activities#schedule-to-start-timeout.
	// Optional: default = unlimited.
	ScheduleToStartTimeout *durationpb.Duration `` /* 131-byte string literal not displayed */
	// The maximum time allowed for a single Activity Task Execution.
	//
	// An Activity Execution must have either this timeout (Start-To-Close)
	// or the Schedule-To-Close Timeout set. We recommend always setting this
	// timeout; however, make sure that it is always set to be longer than the
	// maximum possible time for the Activity Execution to take place. For long
	// running Activity Executions, we recommend also using Activity Heartbeats
	// (`Activity.RecordHeartbeat`) and Heartbeat Timeouts.
	//
	// The main use case for the Start-To-Close timeout is to detect when a
	// Worker crashes after it has started executing an Activity Task.
	//
	// A Retry Policy attached to an Activity Execution retries an Activity
	// Task Execution. Thus, the Start-To-Close Timeout is applied to each
	// Activity Task Execution within an Activity Execution.
	//
	// See https://docs.temporal.io/activities#start-to-close-timeout.
	// Optional: default = [ScheduleToCloseTimeout].
	StartToCloseTimeout *durationpb.Duration `protobuf:"bytes,4,opt,name=start_to_close_timeout,json=startToCloseTimeout,proto3" json:"start_to_close_timeout,omitempty"`
	// The maximum time allowed after the Activity starts, and between Activity
	// Heartbeats (calls to `Activity.RecordHeartbeat`). If this timeout is
	// reached, the Activity Task fails and a retry occurs if a Retry Policy
	// dictates it.
	//
	// See https://docs.temporal.io/activities#activity-heartbeat and
	// https://docs.temporal.io/activities#heartbeat-timeout.
	// Optional: default = unlimited.
	HeartbeatTimeout *durationpb.Duration `protobuf:"bytes,5,opt,name=heartbeat_timeout,json=heartbeatTimeout,proto3" json:"heartbeat_timeout,omitempty"`
	// TODO: Field comment.
	// See https://docs.temporal.io/activities#cancellation.
	// Optional: default = false.
	WaitForCancellation bool `protobuf:"varint,6,opt,name=wait_for_cancellation,json=waitForCancellation,proto3" json:"wait_for_cancellation,omitempty"`
	// TODO: Field comment.
	// See https://docs.temporal.io/activities#activity-id.
	// Optional: default = empty string.
	ActivityId string `protobuf:"bytes,7,opt,name=activity_id,json=activityId,proto3" json:"activity_id,omitempty"`
	// To disable retries set Maximum Attempts to 1.
	// See https://docs.temporal.io/retry-policies for details.
	// Optional: default =
	//
	//	Initial Interval     = 1 second
	//	Backoff Coefficient  = 2.0
	//	Maximum Interval     = 100 × Initial Interval
	//	Maximum Attempts     = 0 (unlimited)
	//	Non-Retryable Errors = none
	RetryPolicy *v11.RetryPolicy `protobuf:"bytes,8,opt,name=retry_policy,json=retryPolicy,proto3" json:"retry_policy,omitempty"`
	// If true, will not request eager execution regardless of worker settings.
	// If false, eager execution may still be disabled at the worker level or
	// eager execution may not be requested due to lack of available slots.
	//
	// Eager activity execution means the server returns requested eager
	// activities directly from the workflow task back to this worker which is
	// faster than non-eager which may be dispatched to a separate worker.
	DisableEagerExecution bool `` /* 127-byte string literal not displayed */
	// contains filtered or unexported fields
}

type StartWorkflowOptions struct {

	// The business identifier of the workflow execution.
	//
	// See https://docs.temporal.io/workflows#workflow-id.
	// Optional: default = system generated UUID.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Workflow tasks are scheduled on the queue with this name. This is also
	// the name of the activity task queue on which activities are scheduled.
	// The workflow author can choose to override this using activity options.
	//
	// See https://docs.temporal.io/tasks#task-queue.
	// Required: no default.
	TaskQueue string `protobuf:"bytes,2,opt,name=task_queue,json=taskQueue,proto3" json:"task_queue,omitempty"`
	// The maximum and total amount of time that a Workflow Execution can
	// be executing, including retries and any usage of Continue-As-New.
	//
	// See https://docs.temporal.io/workflows#workflow-execution-timeout.
	// See also https://docs.temporal.io/workflows#workflow-execution-chain.
	// Optional: default = unlimited.
	WorkflowExecutionTimeout *durationpb.Duration `` /* 135-byte string literal not displayed */
	// The maximum amount of time that a single Workflow Run is restricted to.
	// If this timeout is reached, the Workflow Execution is terminated.
	//
	// See https://docs.temporal.io/workflows#workflow-run-timeout.
	// Optional: default = [WorkflowExecutionTimeout].
	WorkflowRunTimeout *durationpb.Duration `protobuf:"bytes,4,opt,name=workflow_run_timeout,json=workflowRunTimeout,proto3" json:"workflow_run_timeout,omitempty"`
	// The maximum amount of time allowed for a Worker to execute a Workflow
	// Task after the Worker has pulled that Workflow Task from the Task Queue.
	// This timeout is primarily available to recognize whether a Worker has
	// gone down so that the Workflow Execution can be recovered on a different
	// Worker. The main reason for increasing the default value would be to
	// accommodate a Workflow Execution that has a very long Workflow Execution
	// History that could take longer than 10 seconds for the Worker to load.
	//
	// See https://docs.temporal.io/workflows#workflow-task-timeout.
	// Optional: default = 10 secsonds.
	WorkflowTaskTimeout *durationpb.Duration `protobuf:"bytes,5,opt,name=workflow_task_timeout,json=workflowTaskTimeout,proto3" json:"workflow_task_timeout,omitempty"`
	// Whether the server should allow reuse of the workflow ID. Can be useful
	// for dedupe logic if set to `WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE`.
	//
	// Optional: default = `WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE`.
	WorkflowIdReusePolicy v1.WorkflowIdReusePolicy `` /* 178-byte string literal not displayed */
	// When true, `Client.ExecuteWorkflow` will return an error if the workflow
	// ID has already been used and [WorkflowIdReusePolicy] disallows re-runs.
	// When false, rather than erroring, a `WorkflowRun` instance representing
	// the current or last run will be returned.
	//
	// Optional: default = false.
	WorkflowExecutionErrorWhenAlreadyStarted bool `` /* 190-byte string literal not displayed */
	// Typically used in activities rather than workflows, but if a retry
	// policy is specified the server will start a new workflow execution in
	// case of a workflow failure. Either way retries will never exceed
	// [WorkflowExecutionTimeout].
	//
	// See https://docs.temporal.io/retry-policies.
	// Optional: default = none (no retries for workflows).
	RetryPolicy *v11.RetryPolicy `protobuf:"bytes,8,opt,name=retry_policy,json=retryPolicy,proto3" json:"retry_policy,omitempty"`
	// If a cron schedule is specified, the workflow will run as a cron based
	// on the schedule - See https://docs.temporal.io/workflows#temporal-cron-job
	// for details.
	//
	// There are two supported specification formats: "classic" and "robfig" -
	// see details in https://docs.temporal.io/workflows#temporal-cron-job.
	// Cron Schedules are interpreted in UTC time by default, unless prefixed
	// with `CRON_TZ` - see https://docs.temporal.io/workflows#time-zones for
	// details and caveats.
	//
	// The Temporal Server starts the next Run only after the current Run has
	// completed, failed, or reached the [WorkflowRunTimeout]. If [RetryPolicy]
	// is also provided, and a Run fails or times-out, the Run will be retried
	// until it completes or the retry policy has been exhausted. If the next
	// Run, per the cron schedule, is due while the current Run is still Open
	// (including retries), the Server will skip it.
	//
	// A cron workflow will not stop until it is terminated or canceled (by
	// returning `temporal.CanceledError`).
	CronSchedule string `protobuf:"bytes,9,opt,name=cron_schedule,json=cronSchedule,proto3" json:"cron_schedule,omitempty"`
	// contains filtered or unexported fields
}

type Worker struct {
	TaskQueue string         `protobuf:"bytes,1,opt,name=task_queue,json=taskQueue,proto3" json:"task_queue,omitempty"`
	Options   *WorkerOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
	// contains filtered or unexported fields
}

type WorkerOptions struct {

	// Sets the maximum concurrent Activity Executions for the Worker.
	//
	// Optional: default = 0 = 1,000.
	MaxConcurrentActivityExecutionSize int32 `` /* 170-byte string literal not displayed */
	// Rate limits the number of Activity Task Executions started per second
	// for the Worker. The intended use case is to limit resources used by the
	// Worker. Notice that the value type is a float so that the value can be
	// less than 1 if needed. For example, if set to 0.1, Activity Task
	// Executions will happen once every 10 seconds. This can be used to
	// protect downstream services from flooding with requests.
	//
	// See https://docs.temporal.io/tasks#activity-task-execution.
	// Optional: default = 0 = 100,000.
	WorkerActivitiesPerSecond float64 `` /* 142-byte string literal not displayed */
	// Set the maximum concurrent Local Activity Executions for the Worker.
	//
	// See https://docs.temporal.io/activities#local-activity.
	// Optional: default = 0 = 1,000.
	MaxConcurrentLocalActivityExecutionSize int32 `` /* 187-byte string literal not displayed */
	// Rate limits the number of Local Activity Executions per second executed
	// for the Worker. The intended use case is to limit resources used by the
	// Worker. Notice that the value type is a float so that the value can be
	// less than 1 if needed. For example, if set to 0.1, Local Activity Task
	// Executions will happen once every 10 seconds. This can be used to
	// protect downstream services from flooding with requests.
	//
	// See https://docs.temporal.io/tasks#activity-task-execution.
	// Optional: default = 0 = 100,000.
	WorkerLocalActivitiesPerSecond float64 `` /* 159-byte string literal not displayed */
	// Rate limits the number of Activity Executions that can be started per
	// second. This rate is managed by the server and limits the Activity Tasks
	// per second for the entire Task Queue, whereas [WorkerActivitiesPerSecond]
	// controls activities only per worker. Notice that the value type is a
	// float so that the value can be less than 1 if needed. For example, if
	// set to 0.1, Activity Task Executions will happen once every 10 seconds.
	// This can be used to protect downstream services from flooding with
	// requests.
	//
	// See https://docs.temporal.io/tasks#activity-task-execution.
	// Optional: default = 0 = 100,000.
	TaskQueueActivitiesPerSecond float64 `` /* 153-byte string literal not displayed */
	// Sets the maximum number of goroutines to concurrently poll the Task
	// Queue for Activity Tasks. Changing this value will affect the rate at
	// which the Worker is able to consume Activity Tasks from the Task Queue.
	//
	// Optional: default = 2.
	MaxConcurrentActivityTaskPollers int32 `` /* 164-byte string literal not displayed */
	// Sets the maximum number of concurrent Workflow Task Executions the
	// Worker can have. Due to internal logic where pollers alternate between
	// sticky and non-sticky queues, the Worker will panic if this value is set
	// to 1.
	//
	// Optional: default = 0 = 1,000.
	MaxConcurrentWorkflowTaskExecutionSize int32 `` /* 184-byte string literal not displayed */
	// Sets the maximum number of goroutines that will concurrently poll the
	// Task Queue for Workflow Tasks. Changing this value will affect the rate
	// at which the Worker is able to consume Workflow Tasks from the Task
	// Queue. Due to internal logic where pollers alternate between sticky and
	// non-sticky queues, the Worker will panic if this value is set to 1.
	//
	// Optional: default = 2.
	MaxConcurrentWorkflowTaskPollers int32 `` /* 164-byte string literal not displayed */
	// Enable logging in Workflow Execution replays. In Workflow Definitions
	// you can use `workflow.GetLogger(ctx)` to write logs. By default, the
	// logger will skip logging during replays, so you do not see duplicate
	// logs. This is only really useful for debugging purpose.
	//
	// Optional: default = false.
	EnableLoggingInReplay bool `` /* 129-byte string literal not displayed */
	// Sticky Execution runs Workflow Tasks of a Workflow Execution on the same
	// host (could be a different Worker, as long as it is on the same host).
	// This is an optimization for Workflow Executions. When sticky execution
	// is enabled, Worker keeps the Workflow state in memory. A new Workflow
	// Task containing the new history events will be dispatched to the same
	// Worker. If this Worker crashes, the sticky Workflow Task will time-out
	// after [StickyScheduleToStartTimeout], and Temporal Cluster will clear
	// the stickiness for that Workflow Execution and automatically reschedule
	// a new Workflow Task that is available for any Worker to pick up and
	// resume the progress.
	//
	// Optional: default = false.
	//
	// Deprecated: DisableStickyExecution harms performance. It will be removed
	// soon. See `worker.SetStickyWorkflowCacheSize()` instead.
	//
	// Deprecated: Marked as deprecated in worker.proto.
	DisableStickyExecution bool `` /* 131-byte string literal not displayed */
	// The Sticky Execution Schedule-To-Start Timeout for Workflow Tasks. See
	// details about sticky execution in [DisableStickyExecution].
	//
	// Optional: default = 5 seconds.
	StickyScheduleToStartTimeout *durationpb.Duration `` /* 152-byte string literal not displayed */
	// The Worker's graceful stop timeout.
	//
	// Optional: default = 0 seconds.
	WorkerStopTimeout                       *durationpb.Duration `protobuf:"bytes,14,opt,name=worker_stop_timeout,json=workerStopTimeout,proto3" json:"worker_stop_timeout,omitempty"`
	EnableSessionWorker                     bool                 `protobuf:"varint,15,opt,name=enable_session_worker,json=enableSessionWorker,proto3" json:"enable_session_worker,omitempty"`
	MaxConcurrentSessionExecutionSize       int32                `` /* 168-byte string literal not displayed */
	DisableWorkflowWorker                   bool                 `` /* 128-byte string literal not displayed */
	LocalActivityWorkerOnly                 bool                 `` /* 136-byte string literal not displayed */
	Identity                                string               `protobuf:"bytes,19,opt,name=identity,proto3" json:"identity,omitempty"`
	DeadlockDetectionTimeout                *durationpb.Duration `` /* 136-byte string literal not displayed */
	MaxHeartbeatThrottleInterval            *durationpb.Duration `` /* 150-byte string literal not displayed */
	DefaultHeartbeatThrottleInterval        *durationpb.Duration `` /* 162-byte string literal not displayed */
	DisableEagerActivities                  bool                 `` /* 131-byte string literal not displayed */
	MaxConcurrentEagerActivityExecutionSize int32                `` /* 188-byte string literal not displayed */
	DisableRegistrationAliasing             bool                 `` /* 146-byte string literal not displayed */
	BuildId                                 string               `protobuf:"bytes,28,opt,name=build_id,json=buildId,proto3" json:"build_id,omitempty"`
	UseBuildIdForVersioning                 bool                 `` /* 138-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Workflow struct {
	Options *StartWorkflowOptions `protobuf:"bytes,1,opt,name=options,proto3" json:"options,omitempty"`
	// contains filtered or unexported fields
}