flow

type Activity[REQ, RES, STATE any] struct {
	Name string
	Fn   ActivityFunc[REQ, RES, STATE]
	// contains filtered or unexported fields
}

type ActivityContext[REQ, RES, STATE any] struct {
	// contains filtered or unexported fields
}

type ActivityFunc[REQ, RES, STATE any] func(ctx *ActivityContext[REQ, RES, STATE], req REQ) (*RES, error)

type ActivityInfo = activity.Info

type CancelWorkflowRequest struct {
	WorkflowID string
	RunID      string
}

type CancelWorkflowResponse struct {
	Success bool
}

type Channel[T any] struct {
	// contains filtered or unexported fields
}

type Config struct {
	HostPort  string
	Namespace string
	TaskQueue string
}

type Context = workflow.Context

type CountWorkflowRequest struct {
	Query string
}

type CountWorkflowResponse struct {
	Total  int64
	Counts map[string]int64
}

type CreateScheduleRequest struct {
	ID               string
	Action           ScheduleAction
	Spec             ScheduleSpec
	CatchupWindow    time.Duration
	RemainingActions int
	OverlapPolicy    ScheduleOverlapPolicy

	ExecutionTimeout time.Duration
	RunTimeout       time.Duration
	SearchAttributes SearchAttributes
	TimezoneName     string
}

type EMPTY struct{}

type ExecuteActivityOptions struct {
	// ScheduleToCloseTimeout - Total time that a workflow is willing to wait for an Activity to complete.
	// ScheduleToCloseTimeout limits the total time of an Activity's execution, including retries
	// 		(use StartToCloseTimeout to limit the time of a single attempt).
	// The zero value of this uses the default value.
	// Either this option or StartToCloseTimeout is required: Defaults to unlimited.
	ScheduleToCloseTimeout time.Duration

	// ScheduleToStartTimeout - Time that the Activity Task can stay in the Task Queue before it is picked up by
	// a Worker. Do not specify this timeout unless using host-specific Task Queues for Activity Tasks are being
	// used for routing. In almost all situations that don't involve routing activities to specific hosts, it is
	// better to rely on the default value.
	// ScheduleToStartTimeout is always non-retryable. Retrying after this timeout doesn't make sense, as it would
	// just put the Activity Task back into the same Task Queue.
	// Optional: Defaults to unlimited.
	ScheduleToStartTimeout time.Duration

	// StartToCloseTimeout - Maximum time of a single Activity execution attempt.
	// Note that the Temporal Server doesn't detect Worker process failures directly. It relies on this timeout
	// to detect that an Activity that didn't complete on time. So this timeout should be as short as the longest
	// possible execution of the Activity body. Potentially long-running Activities must specify HeartbeatTimeout
	// and call Activity.RecordHeartbeat(ctx, "my-heartbeat") periodically for timely failure detection.
	// Either this option or ScheduleToCloseTimeout is required: Defaults to the ScheduleToCloseTimeout value.
	StartToCloseTimeout time.Duration
	RetryPolicy         *RetryPolicy
}

type ExecuteChildWorkflowOptions struct {
	// WorkflowID of the child workflow to be scheduled.
	// Optional: an auto generated workflowID will be used if this is not provided.
	WorkflowID string

	// TaskQueue that the child workflow needs to be scheduled on.
	// Optional: the parent workflow task queue will be used if this is not provided.
	TaskQueue string

	// WorkflowExecutionTimeout - The end-to-end timeout for the child workflow execution including retries
	// and continue as new.
	// Optional: defaults to unlimited.
	WorkflowExecutionTimeout time.Duration

	// WorkflowRunTimeout - The timeout for a single run of the child workflow execution. Each retry or
	// continue as new should obey this timeout. Use WorkflowExecutionTimeout to specify how long the parent
	// is willing to wait for the child completion.
	// Optional: defaults to WorkflowExecutionTimeout
	WorkflowRunTimeout time.Duration

	// WorkflowTaskTimeout - Maximum execution time of a single Workflow Task. In the majority of cases there is
	// no need to change this timeout. Note that this timeout is not related to the overall Workflow duration in
	// any way. It defines for how long the Workflow can get blocked in the case of a Workflow Worker crash.
	// Default is 10 seconds. The Maximum value allowed by the Temporal Server is 1 minute.
	WorkflowTaskTimeout time.Duration

	// WaitForCancellation - Whether to wait for a canceled child workflow to be ended (child workflow can be ended
	// as: completed/failed/timeout/terminated/canceled)
	// Optional: default false
	WaitForCancellation bool

	// WorkflowIDReusePolicy - Whether server allow reuse of workflow ID, can be useful
	// for dedupe logic if set to WorkflowIdReusePolicyRejectDuplicate
	WorkflowIDReusePolicy enumspb.WorkflowIdReusePolicy

	// RetryPolicy specify how to retry child workflow if error happens.
	// Optional: default is no retry
	RetryPolicy *RetryPolicy

	// ParentClosePolicy specify how the retry child workflow get terminated.
	// default is Terminate
	ParentClosePolicy enumspb.ParentClosePolicy
}

type ExecuteWorkflowOptions struct {
	// ID – The business identifier of the workflow execution.
	// Optional: defaulted to an uuid.
	ID string
	// WorkflowExecutionTimeout – The timeout for the duration of workflow execution.
	// It includes retries and continues as new. Use WorkflowRunTimeout to limit the execution time
	// of a single workflow run.
	// The resolution is seconds.
	// Optional: defaulted to unlimited.
	WorkflowExecutionTimeout time.Duration

	// WorkflowRunTimeout – The timeout for the duration of a single workflow run.
	// The resolution is seconds.
	// Optional: defaulted to WorkflowExecutionTimeout.
	WorkflowRunTimeout time.Duration

	// WorkflowTaskTimeout – The timeout for processing a workflow task from the time the worker
	// pulled this task. If a workflow task is lost, it is retried after this timeout.
	// The resolution is seconds.
	// Optional: defaulted to 10 secs.
	WorkflowTaskTimeout time.Duration
	// StartDelay – Time to wait before dispatching the first workflow task.
	// If the workflow gets a signal before the delay, a workflow task will be dispatched and the rest
	// of the delay will be ignored. A signal from signal with start will not trigger a workflow task.
	// Cannot be set at the same time as a CronSchedule.
	StartDelay time.Duration
	// WorkflowIDReusePolicy
	// Specifies server behavior if a *completed* workflow with the same id exists.
	// This can be useful for dedupe logic if set to RejectDuplicate
	// Optional: defaulted to AllowDuplicate.
	WorkflowIDReusePolicy WorkflowIdReusePolicy

	// WorkflowIDConflictPolicy
	// Specifies server behavior if a *running* workflow with the same id exists.
	// This cannot be set if WorkflowIDReusePolicy is set to TerminateIfRunning.
	// Optional: defaulted to Fail.
	WorkflowIDConflictPolicy WorkflowIdConflictPolicy
}

type Future[M any] struct {
	// contains filtered or unexported fields
}

type GetWorkflowHistoryRequest struct {
	WorkflowID  string
	RunID       string
	Skip        int
	Limit       int
	OnlyLastOne bool
}

type GetWorkflowHistoryResponse struct {
	Events []HistoryEvent
}

type GetWorkflowRequest struct {
	WorkflowID string
	RunID      string
}

type HistoryEvent struct {
	ID      int64
	Type    string
	Time    int64
	Payload map[string]any
}

type RetryPolicy = temporal.RetryPolicy

type SDK struct {
	// contains filtered or unexported fields
}

type ScheduleAction struct {
	WorkflowIDPrefix string
	WorkflowName     string
	WorkflowArg      any
	SearchAttributes SearchAttributes
	RetryPolicy      *RetryPolicy
}

type ScheduleActionResult = client.ScheduleActionResult

type ScheduleEntry = client.ScheduleListEntry

type ScheduleHandle = client.ScheduleHandle

type ScheduleListIterator = client.ScheduleListIterator

type ScheduleOverlapPolicy int32

type ScheduleSpec struct {
	Second     int
	Minute     int
	Hour       int
	Month      int
	Year       int
	DayOfWeek  time.Weekday
	DayOfMonth int // between 1 and 31 inclusive

	StartTime time.Time
	EndTime   time.Time
	Jitter    time.Duration
	Timezone  string
}

type SearchAttributeUpdate = temporal.SearchAttributeUpdate

type SearchAttributes = temporal.SearchAttributes

type SearchWorkflowRequest struct {
	NextPageToken []byte
	Query         string
}

type SearchWorkflowResponse struct {
	Executions    []WorkflowExecution
	NextPageToken []byte
}

type Selector workflow.Selector

type Signal[T any] struct {
	Name string
}

type SignalChannel[T any] struct {
	// contains filtered or unexported fields
}

type UpdateNamespaceRequest struct {
	Description                      *string
	WorkflowExecutionRetentionPeriod *time.Duration
}

type WaitGroup = workflow.WaitGroup

type Workflow[REQ, RES, STATE any] struct {
	Name  string
	State STATE
	Fn    WorkflowFunc[REQ, RES, STATE]
	// contains filtered or unexported fields
}

type WorkflowContext[REQ, RES, STATE any] struct {
	// contains filtered or unexported fields
}

type WorkflowExecution struct {
	Name        string
	WorkflowID  string
	RunID       string
	HistorySize int64
	Memo        string
	StartTime   time.Time
	CloseTime   time.Time
	Duration    time.Duration
	Status      string
}

type WorkflowFilterName string

type WorkflowFunc[REQ, RES, STATE any] func(ctx *WorkflowContext[REQ, RES, STATE], req REQ) (*RES, error)

type WorkflowFuture[M any] struct {
	// contains filtered or unexported fields
}

type WorkflowIdConflictPolicy int32

type WorkflowIdReusePolicy int32

type WorkflowInfo = workflow.Info

type WorkflowRun[T any] struct {
	ID    string
	RunID string
	// contains filtered or unexported fields
}