example_tmprl.pb.go

// Code generated by protoc-gen-go-tmprl. DO NOT EDIT.
//
// version:
//   protoc-gen-go-tmprl version: master
//   protoc-gen-go-tmprl commit: master
//
// source file: example/v1/example.proto

package examplev1

import (
	context "context"
	fmt "fmt"
	uuid "github.com/google/uuid"
	v1 "go.temporal.io/api/common/v1"
	activity "go.temporal.io/sdk/activity"
	client "go.temporal.io/sdk/client"
	converter "go.temporal.io/sdk/converter"
	temporal "go.temporal.io/sdk/temporal"
	worker "go.temporal.io/sdk/worker"
	workflow "go.temporal.io/sdk/workflow"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	time "time"
)

// Constants for Orders service
const (
	// DefaultOrdersTaskQueueName Default task queue name for Orders
	DefaultOrdersTaskQueueName = "orders"

	// DefaultOrdersActivityScheduleToCloseTimeout Default activity schedule to close timeout
	DefaultOrdersActivityScheduleToCloseTimeout = 86400

	// WorkflowProcessOrderName is the registered name for workflow ProcessOrder.
	WorkflowProcessOrderName = "example.v1.Orders.ProcessOrder"

	// WorkflowShipOrderName is the registered name for workflow ShipOrder.
	WorkflowShipOrderName = "example.v1.Orders.ShipOrder"

	// WorkflowDailySalesReportName is the registered name for workflow DailySalesReport.
	WorkflowDailySalesReportName = "example.v1.Orders.DailySalesReport"

	// WorkflowTrackInventoryName is the registered name for workflow TrackInventory.
	WorkflowTrackInventoryName = "example.v1.Orders.TrackInventory"

	// ActivityChargePaymentName is the registered name for activity ChargePayment.
	ActivityChargePaymentName = "example.v1.Orders.ChargePayment"

	// ActivityPackItemsName is the registered name for activity PackItems.
	ActivityPackItemsName = "example.v1.Orders.PackItems"

	// ActivityDispatchCourierName is the registered name for activity DispatchCourier.
	ActivityDispatchCourierName = "courier.Dispatch"

	// SignalCancelOrderName is the registered name for signal CancelOrder.
	SignalCancelOrderName = "example.v1.Orders.CancelOrder"

	// SignalRestockName is the registered name for signal Restock.
	SignalRestockName = "example.v1.Orders.Restock"

	// QueryGetOrderStatusName is the registered name for query GetOrderStatus.
	QueryGetOrderStatusName = "example.v1.Orders.GetOrderStatus"

	// QueryGetStockName is the registered name for query GetStock.
	QueryGetStockName = "example.v1.Orders.GetStock"

	// UpdateChangeShippingAddressName is the registered name for update ChangeShippingAddress.
	UpdateChangeShippingAddressName = "example.v1.Orders.ChangeShippingAddress"

	// UpdateReserveName is the registered name for update Reserve.
	UpdateReserveName = "example.v1.Orders.Reserve"
)

// OrdersService Interface that must be implemented to register workflows and activities
//
// Service Orders is a small e-commerce style fulfillment service used as a
// guided tour of everything this plugin generates:
//
//   - workflows:  ProcessOrder (long lived), ShipOrder (child), DailySalesReport (scheduled)
//   - activities: ChargePayment (retries + non-retryable errors), PackItems (heartbeats), DispatchCourier (custom name)
//   - signals:    CancelOrder
//   - queries:    GetOrderStatus
//   - updates:    ChangeShippingAddress (validated, synchronous request/response)
//
// See `example/worker` for the implementation and `example/client` for a
// runnable walkthrough of all of the above.
type OrdersService interface {
	// ProcessOrder ProcessOrder drives an order from payment to shipping. While it runs it
	// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
	// cancelled (CancelOrder signal)
	ProcessOrder(ctx workflow.Context, req *ProcessOrderRequest) (*ProcessOrderResponse, error)
	// ShipOrder ShipOrder hands the package over to a courier. ProcessOrder runs it as a
	// child workflow so shipping shows up as its own execution in the UI
	ShipOrder(ctx workflow.Context, req *ShipOrderRequest) (*ShipOrderResponse, error)
	// DailySalesReport DailySalesReport is a fast workflow meant to be driven by a Temporal
	// schedule -- see the schedule part of the client walkthrough
	DailySalesReport(ctx workflow.Context, req *emptypb.Empty) (*DailySalesReportResponse, error)
	// TrackInventory TrackInventory is a long-lived "entity" workflow tracking the stock of
	// one SKU. It rolls over with continue-as-new after a number of restocks,
	// which makes it the demo for how BLOCKED updates interact with
	// continue-as-new: the workflow drains its update handlers (see
	// workflow.AllHandlersFinished) before rolling over, so a Reserve update
	// parked on "not enough stock" is answered before the run ends
	TrackInventory(ctx workflow.Context, req *TrackInventoryRequest) (*GetStockResponse, error)
	// ChargePayment ChargePayment captures the money. The retry policy retries transient
	// payment provider hiccups with exponential backoff, but gives up
	// immediately when the card is declined: "CardDeclined" is listed in
	// non_retryable_error_types and the worker returns application errors of
	// that type when the card is bad
	ChargePayment(ctx context.Context, req *ChargePaymentRequest) (*ChargePaymentResponse, error)
	// PackItems PackItems packs the order, one parcel per item. It is slow, so it
	// records a heartbeat after every parcel: if the worker dies mid-pack,
	// Temporal notices within heartbeat_timeout and reschedules the activity
	PackItems(ctx context.Context, req *PackItemsRequest) (*PackItemsResponse, error)
	// DispatchCourier DispatchCourier books a courier and returns a tracking number. The
	// `name` option overrides the registered activity name, which otherwise
	// defaults to <package>.<service>.<method>
	DispatchCourier(ctx context.Context, req *DispatchCourierRequest) (*DispatchCourierResponse, error)
}

// UnimplementedOrdersService Stub implementation that panics
type UnimplementedOrdersService struct{}

func (UnimplementedOrdersService) ProcessOrder(ctx workflow.Context, req *ProcessOrderRequest) (*ProcessOrderResponse, error) {
	panic("ProcessOrder not implemented")
}
func (UnimplementedOrdersService) ShipOrder(ctx workflow.Context, req *ShipOrderRequest) (*ShipOrderResponse, error) {
	panic("ShipOrder not implemented")
}
func (UnimplementedOrdersService) DailySalesReport(ctx workflow.Context, req *emptypb.Empty) (*DailySalesReportResponse, error) {
	panic("DailySalesReport not implemented")
}
func (UnimplementedOrdersService) TrackInventory(ctx workflow.Context, req *TrackInventoryRequest) (*GetStockResponse, error) {
	panic("TrackInventory not implemented")
}
func (UnimplementedOrdersService) ChargePayment(ctx context.Context, req *ChargePaymentRequest) (*ChargePaymentResponse, error) {
	panic("ChargePayment not implemented")
}
func (UnimplementedOrdersService) PackItems(ctx context.Context, req *PackItemsRequest) (*PackItemsResponse, error) {
	panic("PackItems not implemented")
}
func (UnimplementedOrdersService) DispatchCourier(ctx context.Context, req *DispatchCourierRequest) (*DispatchCourierResponse, error) {
	panic("DispatchCourier not implemented")
}

// OrdersClient Client for the Orders service
type OrdersClient struct {
	client    client.Client
	taskQueue string
}

// NewOrdersClient Returns a new instance of the client.
// If `taskQueue` stays empty the default one will be used
func NewOrdersClient(client client.Client, taskQueue ...string) (*OrdersClient, error) {
	clientTaskQueue := DefaultOrdersTaskQueueName
	if len(taskQueue) > 0 {
		clientTaskQueue = taskQueue[0]
	}

	return &OrdersClient{
		client:    client,
		taskQueue: clientTaskQueue,
	}, nil
}

// ExecuteWorkflowProcessOrder executes the workflow and returns a future to it
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) ExecuteWorkflowProcessOrder(ctx context.Context, req *ProcessOrderRequest, options ...client.StartWorkflowOptions) (client.WorkflowRun, error) {
	wOptions := client.StartWorkflowOptions{}
	if len(options) > 0 {
		wOptions = options[0]
	}
	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = c.taskQueue
	}
	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = DefaultOrdersTaskQueueName
	}
	if wOptions.ID == "" {
		wOptions.ID = fmt.Sprintf("%s/%s", WorkflowProcessOrderName, uuid.NewString())
	}

	// Apply timeout options
	if wOptions.WorkflowExecutionTimeout == 0 {
		wOptions.WorkflowExecutionTimeout = time.Duration(3600) * time.Second
	}

	return c.client.ExecuteWorkflow(ctx, wOptions, WorkflowProcessOrderName, req)
}

// ExecuteWorkflowProcessOrderSync executes the workflow and returns the result when finished
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) ExecuteWorkflowProcessOrderSync(ctx context.Context, req *ProcessOrderRequest, options ...client.StartWorkflowOptions) (*ProcessOrderResponse, error) {
	future, err := c.ExecuteWorkflowProcessOrder(ctx, req, options...)
	if err != nil {
		return nil, err
	}

	var resp *ProcessOrderResponse
	err = future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// GetWorkflowProcessOrderResult gets the result of a given workflow
func (c *OrdersClient) GetWorkflowProcessOrderResult(ctx context.Context, workflowId string, runId string) (*ProcessOrderResponse, error) {
	future := c.client.GetWorkflow(ctx, workflowId, runId)

	var resp *ProcessOrderResponse
	err := future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ExecuteChildProcessOrder executes the workflow as a child workflow and returns a future to it
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) ExecuteChildProcessOrder(ctx workflow.Context, req *ProcessOrderRequest, options ...workflow.ChildWorkflowOptions) (workflow.ChildWorkflowFuture, error) {
	wOptions := workflow.ChildWorkflowOptions{}
	if len(options) > 0 {
		wOptions = options[0]
	}

	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = c.taskQueue
	}

	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = DefaultOrdersTaskQueueName
	}
	if wOptions.WorkflowID == "" {
		var id string
		genId := workflow.SideEffect(ctx, func(ctx workflow.Context) interface{} {
			return fmt.Sprintf("%s/%s", WorkflowProcessOrderName, uuid.NewString())
		})

		err := genId.Get(&id)
		if err != nil {
			return nil, err
		}

		wOptions.WorkflowID = id
	}

	// Apply timeout options
	if wOptions.WorkflowExecutionTimeout == 0 {
		wOptions.WorkflowExecutionTimeout = time.Duration(3600) * time.Second
	}

	return workflow.ExecuteChildWorkflow(workflow.WithChildOptions(ctx, wOptions), WorkflowProcessOrderName, req), nil
}

// ExecuteChildProcessOrderSync executes the workflow as a child workflow and returns the result when finished
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) ExecuteChildProcessOrderSync(ctx workflow.Context, req *ProcessOrderRequest, options ...workflow.ChildWorkflowOptions) (*ProcessOrderResponse, error) {
	future, err := c.ExecuteChildProcessOrder(ctx, req, options...)
	if err != nil {
		return nil, err
	}

	var resp *ProcessOrderResponse
	err = future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// CreateScheduleProcessOrder creates a schedule for ProcessOrder
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) CreateScheduleProcessOrder(ctx context.Context, scheduleID string, req *ProcessOrderRequest, options ...client.ScheduleOptions) (client.ScheduleHandle, error) {
	scheduleOptions := client.ScheduleOptions{
		ID: scheduleID,
		Action: &client.ScheduleWorkflowAction{
			ID:                       scheduleID,
			Workflow:                 WorkflowProcessOrderName,
			Args:                     []interface{}{req},
			TaskQueue:                c.taskQueue,
			WorkflowExecutionTimeout: time.Duration(3600) * time.Second,
		},
	}

	if len(options) > 0 {
		mergeScheduleOptionsOrders(&scheduleOptions, options[0], true)
	}
	applyScheduleDefaultsOrders(&scheduleOptions, DefaultOrdersTaskQueueName)

	return c.client.ScheduleClient().Create(ctx, scheduleOptions)
}

// GetScheduleProcessOrder gets a handle to an existing schedule for ProcessOrder
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) GetScheduleProcessOrder(ctx context.Context, scheduleID string) client.ScheduleHandle {
	return c.client.ScheduleClient().GetHandle(ctx, scheduleID)
}

// DescribeScheduleProcessOrder reads a schedule for ProcessOrder and returns the
// DECODED workflow request alongside the full schedule description (spec, policy,
// action timeouts, paused state, ...).
//
// The Temporal SDK returns a schedule action's input arguments as raw, undecoded
// payloads, so this decodes the first argument back into the workflow's request
// type. Pass the same data converter the client was built with when the input is
// encrypted/custom-encoded (e.g. a codec/keyring converter); omit it to use the
// default converter. This is the typed read-back counterpart to
// UpsertScheduleProcessOrder — useful for exporting/backing up schedules.
func (c *OrdersClient) DescribeScheduleProcessOrder(ctx context.Context, scheduleID string, dataConverter ...converter.DataConverter) (*ProcessOrderRequest, *client.ScheduleDescription, error) {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return nil, nil, err
	}

	action, ok := desc.Schedule.Action.(*client.ScheduleWorkflowAction)
	if !ok {
		return nil, desc, fmt.Errorf("schedule %q action is not a workflow action", scheduleID)
	}
	if len(action.Args) == 0 {
		return nil, desc, fmt.Errorf("schedule %q has no input arguments", scheduleID)
	}
	payload, ok := action.Args[0].(*v1.Payload)
	if !ok {
		return nil, desc, fmt.Errorf("schedule %q input argument is not a raw payload (already decoded?)", scheduleID)
	}

	dc := converter.GetDefaultDataConverter()
	if len(dataConverter) > 0 && dataConverter[0] != nil {
		dc = dataConverter[0]
	}

	req := new(ProcessOrderRequest)
	if err := dc.FromPayload(payload, req); err != nil {
		return nil, desc, fmt.Errorf("decoding schedule %q input: %w", scheduleID, err)
	}
	return req, desc, nil
}

// DeleteScheduleProcessOrder deletes a schedule for ProcessOrder
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) DeleteScheduleProcessOrder(ctx context.Context, scheduleID string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	return handle.Delete(ctx)
}

// PauseScheduleProcessOrder pauses a running schedule for ProcessOrder. The note is
// recorded by Temporal on the schedule's audit trail (visible via Describe). If
// the schedule is already paused this is a no-op: we Describe first and skip the
// Pause API call when .Schedule.State.Paused is already true, so it's safe to
// call on every reconcile/bootstrap path without spamming the server.
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) PauseScheduleProcessOrder(ctx context.Context, scheduleID string, note string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return err
	}
	if desc.Schedule.State != nil && desc.Schedule.State.Paused {
		return nil
	}
	return handle.Pause(ctx, client.SchedulePauseOptions{Note: note})
}

// UnpauseScheduleProcessOrder resumes a paused schedule for ProcessOrder. Like
// PauseScheduleProcessOrder, this is a read-then-write: we Describe first and
// return nil if the schedule is already running, so idempotent bootstrap code
// doesn't pay an extra Unpause round-trip per reconcile tick.
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) UnpauseScheduleProcessOrder(ctx context.Context, scheduleID string, note string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return err
	}
	if desc.Schedule.State == nil || !desc.Schedule.State.Paused {
		return nil
	}
	return handle.Unpause(ctx, client.ScheduleUnpauseOptions{Note: note})
}

// ListScheduleProcessOrder lists all schedules for ProcessOrder workflow
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) ListScheduleProcessOrder(ctx context.Context, pageSize int) ([]client.ScheduleListEntry, error) {
	var schedules []client.ScheduleListEntry

	iter, err := c.client.ScheduleClient().List(ctx, client.ScheduleListOptions{
		PageSize: pageSize,
	})
	if err != nil {
		return nil, err
	}

	for iter.HasNext() {
		entry, err := iter.Next()
		if err != nil {
			return nil, err
		}

		// Filter by workflow type
		if entry.WorkflowType.Name == WorkflowProcessOrderName {
			schedules = append(schedules, *entry)
		}
	}

	return schedules, nil
}

// UpsertScheduleProcessOrder creates or updates a schedule for ProcessOrder
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
func (c *OrdersClient) UpsertScheduleProcessOrder(ctx context.Context, scheduleID string, req *ProcessOrderRequest, options ...client.ScheduleOptions) (client.ScheduleHandle, error) {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)

	// Try to describe the schedule to see if it exists
	_, err := handle.Describe(ctx)
	if err != nil {
		// Schedule doesn't exist, create it
		return c.CreateScheduleProcessOrder(ctx, scheduleID, req, options...)
	}

	// Schedule exists, update it
	scheduleOptions := client.ScheduleOptions{
		ID: scheduleID,
		Action: &client.ScheduleWorkflowAction{
			ID:                       scheduleID,
			Workflow:                 WorkflowProcessOrderName,
			Args:                     []interface{}{req},
			TaskQueue:                c.taskQueue,
			WorkflowExecutionTimeout: time.Duration(3600) * time.Second,
		},
	}

	if len(options) > 0 {
		// Upsert never flips Paused on a running schedule; everything else merges
		// identically to CreateSchedule.
		mergeScheduleOptionsOrders(&scheduleOptions, options[0], false)
	}
	applyScheduleDefaultsOrders(&scheduleOptions, DefaultOrdersTaskQueueName)

	// Update the schedule. The closure starts from the schedule as it exists on
	// the server (input.Description.Schedule) and overlays ONLY what the caller
	// supplied, so an upsert that just changes the request does not silently
	// blank the spec, drop search attributes, or reset sibling policy fields.
	err = handle.Update(ctx, client.ScheduleUpdateOptions{
		DoUpdate: func(input client.ScheduleUpdateInput) (*client.ScheduleUpdate, error) {
			schedule := input.Description.Schedule

			// Rebind the action so the updated request/args take effect.
			schedule.Action = scheduleOptions.Action

			// Only replace the spec when the caller supplied scheduling info;
			// otherwise keep the existing spec so the schedule keeps firing.
			if !scheduleSpecIsZeroOrders(scheduleOptions.Spec) {
				schedule.Spec = &scheduleOptions.Spec
			}

			// Merge policy fields onto the existing policy instead of replacing
			// it, so changing one field does not reset the others.
			if scheduleOptions.Overlap != 0 || scheduleOptions.CatchupWindow != 0 || scheduleOptions.PauseOnFailure {
				if schedule.Policy == nil {
					schedule.Policy = &client.SchedulePolicies{}
				}
				if scheduleOptions.Overlap != 0 {
					schedule.Policy.Overlap = scheduleOptions.Overlap
				}
				if scheduleOptions.CatchupWindow != 0 {
					schedule.Policy.CatchupWindow = scheduleOptions.CatchupWindow
				}
				if scheduleOptions.PauseOnFailure {
					schedule.Policy.PauseOnFailure = scheduleOptions.PauseOnFailure
				}
			}

			update := &client.ScheduleUpdate{Schedule: &schedule}
			// A nil pointer leaves the schedule's search attributes intact; only
			// send a non-empty set (an empty non-nil set removes all of them).
			if scheduleOptions.TypedSearchAttributes.Size() > 0 {
				update.TypedSearchAttributes = &scheduleOptions.TypedSearchAttributes
			}
			return update, nil
		},
	})
	if err != nil {
		return nil, err
	}

	return handle, nil
}

// ExecuteWorkflowShipOrder executes the workflow and returns a future to it
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) ExecuteWorkflowShipOrder(ctx context.Context, req *ShipOrderRequest, options ...client.StartWorkflowOptions) (client.WorkflowRun, error) {
	wOptions := client.StartWorkflowOptions{}
	if len(options) > 0 {
		wOptions = options[0]
	}
	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = c.taskQueue
	}
	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = DefaultOrdersTaskQueueName
	}
	if wOptions.ID == "" {
		wOptions.ID = fmt.Sprintf("%s/%s", WorkflowShipOrderName, uuid.NewString())
	}

	// Apply timeout options
	if wOptions.WorkflowExecutionTimeout == 0 {
		wOptions.WorkflowExecutionTimeout = time.Duration(3600) * time.Second
	}

	return c.client.ExecuteWorkflow(ctx, wOptions, WorkflowShipOrderName, req)
}

// ExecuteWorkflowShipOrderSync executes the workflow and returns the result when finished
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) ExecuteWorkflowShipOrderSync(ctx context.Context, req *ShipOrderRequest, options ...client.StartWorkflowOptions) (*ShipOrderResponse, error) {
	future, err := c.ExecuteWorkflowShipOrder(ctx, req, options...)
	if err != nil {
		return nil, err
	}

	var resp *ShipOrderResponse
	err = future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// GetWorkflowShipOrderResult gets the result of a given workflow
func (c *OrdersClient) GetWorkflowShipOrderResult(ctx context.Context, workflowId string, runId string) (*ShipOrderResponse, error) {
	future := c.client.GetWorkflow(ctx, workflowId, runId)

	var resp *ShipOrderResponse
	err := future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ExecuteChildShipOrder executes the workflow as a child workflow and returns a future to it
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) ExecuteChildShipOrder(ctx workflow.Context, req *ShipOrderRequest, options ...workflow.ChildWorkflowOptions) (workflow.ChildWorkflowFuture, error) {
	wOptions := workflow.ChildWorkflowOptions{}
	if len(options) > 0 {
		wOptions = options[0]
	}

	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = c.taskQueue
	}

	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = DefaultOrdersTaskQueueName
	}
	if wOptions.WorkflowID == "" {
		var id string
		genId := workflow.SideEffect(ctx, func(ctx workflow.Context) interface{} {
			return fmt.Sprintf("%s/%s", WorkflowShipOrderName, uuid.NewString())
		})

		err := genId.Get(&id)
		if err != nil {
			return nil, err
		}

		wOptions.WorkflowID = id
	}

	// Apply timeout options
	if wOptions.WorkflowExecutionTimeout == 0 {
		wOptions.WorkflowExecutionTimeout = time.Duration(3600) * time.Second
	}

	return workflow.ExecuteChildWorkflow(workflow.WithChildOptions(ctx, wOptions), WorkflowShipOrderName, req), nil
}

// ExecuteChildShipOrderSync executes the workflow as a child workflow and returns the result when finished
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) ExecuteChildShipOrderSync(ctx workflow.Context, req *ShipOrderRequest, options ...workflow.ChildWorkflowOptions) (*ShipOrderResponse, error) {
	future, err := c.ExecuteChildShipOrder(ctx, req, options...)
	if err != nil {
		return nil, err
	}

	var resp *ShipOrderResponse
	err = future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// CreateScheduleShipOrder creates a schedule for ShipOrder
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) CreateScheduleShipOrder(ctx context.Context, scheduleID string, req *ShipOrderRequest, options ...client.ScheduleOptions) (client.ScheduleHandle, error) {
	scheduleOptions := client.ScheduleOptions{
		ID: scheduleID,
		Action: &client.ScheduleWorkflowAction{
			ID:                       scheduleID,
			Workflow:                 WorkflowShipOrderName,
			Args:                     []interface{}{req},
			TaskQueue:                c.taskQueue,
			WorkflowExecutionTimeout: time.Duration(3600) * time.Second,
		},
	}

	if len(options) > 0 {
		mergeScheduleOptionsOrders(&scheduleOptions, options[0], true)
	}
	applyScheduleDefaultsOrders(&scheduleOptions, DefaultOrdersTaskQueueName)

	return c.client.ScheduleClient().Create(ctx, scheduleOptions)
}

// GetScheduleShipOrder gets a handle to an existing schedule for ShipOrder
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) GetScheduleShipOrder(ctx context.Context, scheduleID string) client.ScheduleHandle {
	return c.client.ScheduleClient().GetHandle(ctx, scheduleID)
}

// DescribeScheduleShipOrder reads a schedule for ShipOrder and returns the
// DECODED workflow request alongside the full schedule description (spec, policy,
// action timeouts, paused state, ...).
//
// The Temporal SDK returns a schedule action's input arguments as raw, undecoded
// payloads, so this decodes the first argument back into the workflow's request
// type. Pass the same data converter the client was built with when the input is
// encrypted/custom-encoded (e.g. a codec/keyring converter); omit it to use the
// default converter. This is the typed read-back counterpart to
// UpsertScheduleShipOrder — useful for exporting/backing up schedules.
func (c *OrdersClient) DescribeScheduleShipOrder(ctx context.Context, scheduleID string, dataConverter ...converter.DataConverter) (*ShipOrderRequest, *client.ScheduleDescription, error) {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return nil, nil, err
	}

	action, ok := desc.Schedule.Action.(*client.ScheduleWorkflowAction)
	if !ok {
		return nil, desc, fmt.Errorf("schedule %q action is not a workflow action", scheduleID)
	}
	if len(action.Args) == 0 {
		return nil, desc, fmt.Errorf("schedule %q has no input arguments", scheduleID)
	}
	payload, ok := action.Args[0].(*v1.Payload)
	if !ok {
		return nil, desc, fmt.Errorf("schedule %q input argument is not a raw payload (already decoded?)", scheduleID)
	}

	dc := converter.GetDefaultDataConverter()
	if len(dataConverter) > 0 && dataConverter[0] != nil {
		dc = dataConverter[0]
	}

	req := new(ShipOrderRequest)
	if err := dc.FromPayload(payload, req); err != nil {
		return nil, desc, fmt.Errorf("decoding schedule %q input: %w", scheduleID, err)
	}
	return req, desc, nil
}

// DeleteScheduleShipOrder deletes a schedule for ShipOrder
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) DeleteScheduleShipOrder(ctx context.Context, scheduleID string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	return handle.Delete(ctx)
}

// PauseScheduleShipOrder pauses a running schedule for ShipOrder. The note is
// recorded by Temporal on the schedule's audit trail (visible via Describe). If
// the schedule is already paused this is a no-op: we Describe first and skip the
// Pause API call when .Schedule.State.Paused is already true, so it's safe to
// call on every reconcile/bootstrap path without spamming the server.
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) PauseScheduleShipOrder(ctx context.Context, scheduleID string, note string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return err
	}
	if desc.Schedule.State != nil && desc.Schedule.State.Paused {
		return nil
	}
	return handle.Pause(ctx, client.SchedulePauseOptions{Note: note})
}

// UnpauseScheduleShipOrder resumes a paused schedule for ShipOrder. Like
// PauseScheduleShipOrder, this is a read-then-write: we Describe first and
// return nil if the schedule is already running, so idempotent bootstrap code
// doesn't pay an extra Unpause round-trip per reconcile tick.
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) UnpauseScheduleShipOrder(ctx context.Context, scheduleID string, note string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return err
	}
	if desc.Schedule.State == nil || !desc.Schedule.State.Paused {
		return nil
	}
	return handle.Unpause(ctx, client.ScheduleUnpauseOptions{Note: note})
}

// ListScheduleShipOrder lists all schedules for ShipOrder workflow
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) ListScheduleShipOrder(ctx context.Context, pageSize int) ([]client.ScheduleListEntry, error) {
	var schedules []client.ScheduleListEntry

	iter, err := c.client.ScheduleClient().List(ctx, client.ScheduleListOptions{
		PageSize: pageSize,
	})
	if err != nil {
		return nil, err
	}

	for iter.HasNext() {
		entry, err := iter.Next()
		if err != nil {
			return nil, err
		}

		// Filter by workflow type
		if entry.WorkflowType.Name == WorkflowShipOrderName {
			schedules = append(schedules, *entry)
		}
	}

	return schedules, nil
}

// UpsertScheduleShipOrder creates or updates a schedule for ShipOrder
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
func (c *OrdersClient) UpsertScheduleShipOrder(ctx context.Context, scheduleID string, req *ShipOrderRequest, options ...client.ScheduleOptions) (client.ScheduleHandle, error) {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)

	// Try to describe the schedule to see if it exists
	_, err := handle.Describe(ctx)
	if err != nil {
		// Schedule doesn't exist, create it
		return c.CreateScheduleShipOrder(ctx, scheduleID, req, options...)
	}

	// Schedule exists, update it
	scheduleOptions := client.ScheduleOptions{
		ID: scheduleID,
		Action: &client.ScheduleWorkflowAction{
			ID:                       scheduleID,
			Workflow:                 WorkflowShipOrderName,
			Args:                     []interface{}{req},
			TaskQueue:                c.taskQueue,
			WorkflowExecutionTimeout: time.Duration(3600) * time.Second,
		},
	}

	if len(options) > 0 {
		// Upsert never flips Paused on a running schedule; everything else merges
		// identically to CreateSchedule.
		mergeScheduleOptionsOrders(&scheduleOptions, options[0], false)
	}
	applyScheduleDefaultsOrders(&scheduleOptions, DefaultOrdersTaskQueueName)

	// Update the schedule. The closure starts from the schedule as it exists on
	// the server (input.Description.Schedule) and overlays ONLY what the caller
	// supplied, so an upsert that just changes the request does not silently
	// blank the spec, drop search attributes, or reset sibling policy fields.
	err = handle.Update(ctx, client.ScheduleUpdateOptions{
		DoUpdate: func(input client.ScheduleUpdateInput) (*client.ScheduleUpdate, error) {
			schedule := input.Description.Schedule

			// Rebind the action so the updated request/args take effect.
			schedule.Action = scheduleOptions.Action

			// Only replace the spec when the caller supplied scheduling info;
			// otherwise keep the existing spec so the schedule keeps firing.
			if !scheduleSpecIsZeroOrders(scheduleOptions.Spec) {
				schedule.Spec = &scheduleOptions.Spec
			}

			// Merge policy fields onto the existing policy instead of replacing
			// it, so changing one field does not reset the others.
			if scheduleOptions.Overlap != 0 || scheduleOptions.CatchupWindow != 0 || scheduleOptions.PauseOnFailure {
				if schedule.Policy == nil {
					schedule.Policy = &client.SchedulePolicies{}
				}
				if scheduleOptions.Overlap != 0 {
					schedule.Policy.Overlap = scheduleOptions.Overlap
				}
				if scheduleOptions.CatchupWindow != 0 {
					schedule.Policy.CatchupWindow = scheduleOptions.CatchupWindow
				}
				if scheduleOptions.PauseOnFailure {
					schedule.Policy.PauseOnFailure = scheduleOptions.PauseOnFailure
				}
			}

			update := &client.ScheduleUpdate{Schedule: &schedule}
			// A nil pointer leaves the schedule's search attributes intact; only
			// send a non-empty set (an empty non-nil set removes all of them).
			if scheduleOptions.TypedSearchAttributes.Size() > 0 {
				update.TypedSearchAttributes = &scheduleOptions.TypedSearchAttributes
			}
			return update, nil
		},
	})
	if err != nil {
		return nil, err
	}

	return handle, nil
}

// ExecuteWorkflowDailySalesReport executes the workflow and returns a future to it
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) ExecuteWorkflowDailySalesReport(ctx context.Context, req *emptypb.Empty, options ...client.StartWorkflowOptions) (client.WorkflowRun, error) {
	wOptions := client.StartWorkflowOptions{}
	if len(options) > 0 {
		wOptions = options[0]
	}
	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = c.taskQueue
	}
	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = DefaultOrdersTaskQueueName
	}
	if wOptions.ID == "" {
		wOptions.ID = fmt.Sprintf("%s/%s", WorkflowDailySalesReportName, uuid.NewString())
	}

	// Apply timeout options
	if wOptions.WorkflowExecutionTimeout == 0 {
		wOptions.WorkflowExecutionTimeout = time.Duration(3600) * time.Second
	}

	return c.client.ExecuteWorkflow(ctx, wOptions, WorkflowDailySalesReportName, req)
}

// ExecuteWorkflowDailySalesReportSync executes the workflow and returns the result when finished
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) ExecuteWorkflowDailySalesReportSync(ctx context.Context, req *emptypb.Empty, options ...client.StartWorkflowOptions) (*DailySalesReportResponse, error) {
	future, err := c.ExecuteWorkflowDailySalesReport(ctx, req, options...)
	if err != nil {
		return nil, err
	}

	var resp *DailySalesReportResponse
	err = future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// GetWorkflowDailySalesReportResult gets the result of a given workflow
func (c *OrdersClient) GetWorkflowDailySalesReportResult(ctx context.Context, workflowId string, runId string) (*DailySalesReportResponse, error) {
	future := c.client.GetWorkflow(ctx, workflowId, runId)

	var resp *DailySalesReportResponse
	err := future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ExecuteChildDailySalesReport executes the workflow as a child workflow and returns a future to it
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) ExecuteChildDailySalesReport(ctx workflow.Context, req *emptypb.Empty, options ...workflow.ChildWorkflowOptions) (workflow.ChildWorkflowFuture, error) {
	wOptions := workflow.ChildWorkflowOptions{}
	if len(options) > 0 {
		wOptions = options[0]
	}

	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = c.taskQueue
	}

	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = DefaultOrdersTaskQueueName
	}
	if wOptions.WorkflowID == "" {
		var id string
		genId := workflow.SideEffect(ctx, func(ctx workflow.Context) interface{} {
			return fmt.Sprintf("%s/%s", WorkflowDailySalesReportName, uuid.NewString())
		})

		err := genId.Get(&id)
		if err != nil {
			return nil, err
		}

		wOptions.WorkflowID = id
	}

	// Apply timeout options
	if wOptions.WorkflowExecutionTimeout == 0 {
		wOptions.WorkflowExecutionTimeout = time.Duration(3600) * time.Second
	}

	return workflow.ExecuteChildWorkflow(workflow.WithChildOptions(ctx, wOptions), WorkflowDailySalesReportName, req), nil
}

// ExecuteChildDailySalesReportSync executes the workflow as a child workflow and returns the result when finished
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) ExecuteChildDailySalesReportSync(ctx workflow.Context, req *emptypb.Empty, options ...workflow.ChildWorkflowOptions) (*DailySalesReportResponse, error) {
	future, err := c.ExecuteChildDailySalesReport(ctx, req, options...)
	if err != nil {
		return nil, err
	}

	var resp *DailySalesReportResponse
	err = future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// CreateScheduleDailySalesReport creates a schedule for DailySalesReport
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) CreateScheduleDailySalesReport(ctx context.Context, scheduleID string, req *emptypb.Empty, options ...client.ScheduleOptions) (client.ScheduleHandle, error) {
	scheduleOptions := client.ScheduleOptions{
		ID: scheduleID,
		Action: &client.ScheduleWorkflowAction{
			ID:                       scheduleID,
			Workflow:                 WorkflowDailySalesReportName,
			Args:                     []interface{}{req},
			TaskQueue:                c.taskQueue,
			WorkflowExecutionTimeout: time.Duration(3600) * time.Second,
		},
	}

	if len(options) > 0 {
		mergeScheduleOptionsOrders(&scheduleOptions, options[0], true)
	}
	applyScheduleDefaultsOrders(&scheduleOptions, DefaultOrdersTaskQueueName)

	return c.client.ScheduleClient().Create(ctx, scheduleOptions)
}

// GetScheduleDailySalesReport gets a handle to an existing schedule for DailySalesReport
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) GetScheduleDailySalesReport(ctx context.Context, scheduleID string) client.ScheduleHandle {
	return c.client.ScheduleClient().GetHandle(ctx, scheduleID)
}

// DescribeScheduleDailySalesReport reads a schedule for DailySalesReport and returns the
// DECODED workflow request alongside the full schedule description (spec, policy,
// action timeouts, paused state, ...).
//
// The Temporal SDK returns a schedule action's input arguments as raw, undecoded
// payloads, so this decodes the first argument back into the workflow's request
// type. Pass the same data converter the client was built with when the input is
// encrypted/custom-encoded (e.g. a codec/keyring converter); omit it to use the
// default converter. This is the typed read-back counterpart to
// UpsertScheduleDailySalesReport — useful for exporting/backing up schedules.
func (c *OrdersClient) DescribeScheduleDailySalesReport(ctx context.Context, scheduleID string, dataConverter ...converter.DataConverter) (*emptypb.Empty, *client.ScheduleDescription, error) {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return nil, nil, err
	}

	action, ok := desc.Schedule.Action.(*client.ScheduleWorkflowAction)
	if !ok {
		return nil, desc, fmt.Errorf("schedule %q action is not a workflow action", scheduleID)
	}
	if len(action.Args) == 0 {
		return nil, desc, fmt.Errorf("schedule %q has no input arguments", scheduleID)
	}
	payload, ok := action.Args[0].(*v1.Payload)
	if !ok {
		return nil, desc, fmt.Errorf("schedule %q input argument is not a raw payload (already decoded?)", scheduleID)
	}

	dc := converter.GetDefaultDataConverter()
	if len(dataConverter) > 0 && dataConverter[0] != nil {
		dc = dataConverter[0]
	}

	req := new(emptypb.Empty)
	if err := dc.FromPayload(payload, req); err != nil {
		return nil, desc, fmt.Errorf("decoding schedule %q input: %w", scheduleID, err)
	}
	return req, desc, nil
}

// DeleteScheduleDailySalesReport deletes a schedule for DailySalesReport
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) DeleteScheduleDailySalesReport(ctx context.Context, scheduleID string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	return handle.Delete(ctx)
}

// PauseScheduleDailySalesReport pauses a running schedule for DailySalesReport. The note is
// recorded by Temporal on the schedule's audit trail (visible via Describe). If
// the schedule is already paused this is a no-op: we Describe first and skip the
// Pause API call when .Schedule.State.Paused is already true, so it's safe to
// call on every reconcile/bootstrap path without spamming the server.
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) PauseScheduleDailySalesReport(ctx context.Context, scheduleID string, note string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return err
	}
	if desc.Schedule.State != nil && desc.Schedule.State.Paused {
		return nil
	}
	return handle.Pause(ctx, client.SchedulePauseOptions{Note: note})
}

// UnpauseScheduleDailySalesReport resumes a paused schedule for DailySalesReport. Like
// PauseScheduleDailySalesReport, this is a read-then-write: we Describe first and
// return nil if the schedule is already running, so idempotent bootstrap code
// doesn't pay an extra Unpause round-trip per reconcile tick.
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) UnpauseScheduleDailySalesReport(ctx context.Context, scheduleID string, note string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return err
	}
	if desc.Schedule.State == nil || !desc.Schedule.State.Paused {
		return nil
	}
	return handle.Unpause(ctx, client.ScheduleUnpauseOptions{Note: note})
}

// ListScheduleDailySalesReport lists all schedules for DailySalesReport workflow
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) ListScheduleDailySalesReport(ctx context.Context, pageSize int) ([]client.ScheduleListEntry, error) {
	var schedules []client.ScheduleListEntry

	iter, err := c.client.ScheduleClient().List(ctx, client.ScheduleListOptions{
		PageSize: pageSize,
	})
	if err != nil {
		return nil, err
	}

	for iter.HasNext() {
		entry, err := iter.Next()
		if err != nil {
			return nil, err
		}

		// Filter by workflow type
		if entry.WorkflowType.Name == WorkflowDailySalesReportName {
			schedules = append(schedules, *entry)
		}
	}

	return schedules, nil
}

// UpsertScheduleDailySalesReport creates or updates a schedule for DailySalesReport
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
func (c *OrdersClient) UpsertScheduleDailySalesReport(ctx context.Context, scheduleID string, req *emptypb.Empty, options ...client.ScheduleOptions) (client.ScheduleHandle, error) {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)

	// Try to describe the schedule to see if it exists
	_, err := handle.Describe(ctx)
	if err != nil {
		// Schedule doesn't exist, create it
		return c.CreateScheduleDailySalesReport(ctx, scheduleID, req, options...)
	}

	// Schedule exists, update it
	scheduleOptions := client.ScheduleOptions{
		ID: scheduleID,
		Action: &client.ScheduleWorkflowAction{
			ID:                       scheduleID,
			Workflow:                 WorkflowDailySalesReportName,
			Args:                     []interface{}{req},
			TaskQueue:                c.taskQueue,
			WorkflowExecutionTimeout: time.Duration(3600) * time.Second,
		},
	}

	if len(options) > 0 {
		// Upsert never flips Paused on a running schedule; everything else merges
		// identically to CreateSchedule.
		mergeScheduleOptionsOrders(&scheduleOptions, options[0], false)
	}
	applyScheduleDefaultsOrders(&scheduleOptions, DefaultOrdersTaskQueueName)

	// Update the schedule. The closure starts from the schedule as it exists on
	// the server (input.Description.Schedule) and overlays ONLY what the caller
	// supplied, so an upsert that just changes the request does not silently
	// blank the spec, drop search attributes, or reset sibling policy fields.
	err = handle.Update(ctx, client.ScheduleUpdateOptions{
		DoUpdate: func(input client.ScheduleUpdateInput) (*client.ScheduleUpdate, error) {
			schedule := input.Description.Schedule

			// Rebind the action so the updated request/args take effect.
			schedule.Action = scheduleOptions.Action

			// Only replace the spec when the caller supplied scheduling info;
			// otherwise keep the existing spec so the schedule keeps firing.
			if !scheduleSpecIsZeroOrders(scheduleOptions.Spec) {
				schedule.Spec = &scheduleOptions.Spec
			}

			// Merge policy fields onto the existing policy instead of replacing
			// it, so changing one field does not reset the others.
			if scheduleOptions.Overlap != 0 || scheduleOptions.CatchupWindow != 0 || scheduleOptions.PauseOnFailure {
				if schedule.Policy == nil {
					schedule.Policy = &client.SchedulePolicies{}
				}
				if scheduleOptions.Overlap != 0 {
					schedule.Policy.Overlap = scheduleOptions.Overlap
				}
				if scheduleOptions.CatchupWindow != 0 {
					schedule.Policy.CatchupWindow = scheduleOptions.CatchupWindow
				}
				if scheduleOptions.PauseOnFailure {
					schedule.Policy.PauseOnFailure = scheduleOptions.PauseOnFailure
				}
			}

			update := &client.ScheduleUpdate{Schedule: &schedule}
			// A nil pointer leaves the schedule's search attributes intact; only
			// send a non-empty set (an empty non-nil set removes all of them).
			if scheduleOptions.TypedSearchAttributes.Size() > 0 {
				update.TypedSearchAttributes = &scheduleOptions.TypedSearchAttributes
			}
			return update, nil
		},
	})
	if err != nil {
		return nil, err
	}

	return handle, nil
}

// ExecuteWorkflowTrackInventory executes the workflow and returns a future to it
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) ExecuteWorkflowTrackInventory(ctx context.Context, req *TrackInventoryRequest, options ...client.StartWorkflowOptions) (client.WorkflowRun, error) {
	wOptions := client.StartWorkflowOptions{}
	if len(options) > 0 {
		wOptions = options[0]
	}
	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = c.taskQueue
	}
	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = DefaultOrdersTaskQueueName
	}
	if wOptions.ID == "" {
		wOptions.ID = fmt.Sprintf("%s/%s", WorkflowTrackInventoryName, uuid.NewString())
	}

	// Apply timeout options
	if wOptions.WorkflowExecutionTimeout == 0 {
		wOptions.WorkflowExecutionTimeout = time.Duration(3600) * time.Second
	}

	return c.client.ExecuteWorkflow(ctx, wOptions, WorkflowTrackInventoryName, req)
}

// ExecuteWorkflowTrackInventorySync executes the workflow and returns the result when finished
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) ExecuteWorkflowTrackInventorySync(ctx context.Context, req *TrackInventoryRequest, options ...client.StartWorkflowOptions) (*GetStockResponse, error) {
	future, err := c.ExecuteWorkflowTrackInventory(ctx, req, options...)
	if err != nil {
		return nil, err
	}

	var resp *GetStockResponse
	err = future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// GetWorkflowTrackInventoryResult gets the result of a given workflow
func (c *OrdersClient) GetWorkflowTrackInventoryResult(ctx context.Context, workflowId string, runId string) (*GetStockResponse, error) {
	future := c.client.GetWorkflow(ctx, workflowId, runId)

	var resp *GetStockResponse
	err := future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ExecuteChildTrackInventory executes the workflow as a child workflow and returns a future to it
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) ExecuteChildTrackInventory(ctx workflow.Context, req *TrackInventoryRequest, options ...workflow.ChildWorkflowOptions) (workflow.ChildWorkflowFuture, error) {
	wOptions := workflow.ChildWorkflowOptions{}
	if len(options) > 0 {
		wOptions = options[0]
	}

	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = c.taskQueue
	}

	if wOptions.TaskQueue == "" {
		wOptions.TaskQueue = DefaultOrdersTaskQueueName
	}
	if wOptions.WorkflowID == "" {
		var id string
		genId := workflow.SideEffect(ctx, func(ctx workflow.Context) interface{} {
			return fmt.Sprintf("%s/%s", WorkflowTrackInventoryName, uuid.NewString())
		})

		err := genId.Get(&id)
		if err != nil {
			return nil, err
		}

		wOptions.WorkflowID = id
	}

	// Apply timeout options
	if wOptions.WorkflowExecutionTimeout == 0 {
		wOptions.WorkflowExecutionTimeout = time.Duration(3600) * time.Second
	}

	return workflow.ExecuteChildWorkflow(workflow.WithChildOptions(ctx, wOptions), WorkflowTrackInventoryName, req), nil
}

// ExecuteChildTrackInventorySync executes the workflow as a child workflow and returns the result when finished
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) ExecuteChildTrackInventorySync(ctx workflow.Context, req *TrackInventoryRequest, options ...workflow.ChildWorkflowOptions) (*GetStockResponse, error) {
	future, err := c.ExecuteChildTrackInventory(ctx, req, options...)
	if err != nil {
		return nil, err
	}

	var resp *GetStockResponse
	err = future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// CreateScheduleTrackInventory creates a schedule for TrackInventory
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) CreateScheduleTrackInventory(ctx context.Context, scheduleID string, req *TrackInventoryRequest, options ...client.ScheduleOptions) (client.ScheduleHandle, error) {
	scheduleOptions := client.ScheduleOptions{
		ID: scheduleID,
		Action: &client.ScheduleWorkflowAction{
			ID:                       scheduleID,
			Workflow:                 WorkflowTrackInventoryName,
			Args:                     []interface{}{req},
			TaskQueue:                c.taskQueue,
			WorkflowExecutionTimeout: time.Duration(3600) * time.Second,
		},
	}

	if len(options) > 0 {
		mergeScheduleOptionsOrders(&scheduleOptions, options[0], true)
	}
	applyScheduleDefaultsOrders(&scheduleOptions, DefaultOrdersTaskQueueName)

	return c.client.ScheduleClient().Create(ctx, scheduleOptions)
}

// GetScheduleTrackInventory gets a handle to an existing schedule for TrackInventory
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) GetScheduleTrackInventory(ctx context.Context, scheduleID string) client.ScheduleHandle {
	return c.client.ScheduleClient().GetHandle(ctx, scheduleID)
}

// DescribeScheduleTrackInventory reads a schedule for TrackInventory and returns the
// DECODED workflow request alongside the full schedule description (spec, policy,
// action timeouts, paused state, ...).
//
// The Temporal SDK returns a schedule action's input arguments as raw, undecoded
// payloads, so this decodes the first argument back into the workflow's request
// type. Pass the same data converter the client was built with when the input is
// encrypted/custom-encoded (e.g. a codec/keyring converter); omit it to use the
// default converter. This is the typed read-back counterpart to
// UpsertScheduleTrackInventory — useful for exporting/backing up schedules.
func (c *OrdersClient) DescribeScheduleTrackInventory(ctx context.Context, scheduleID string, dataConverter ...converter.DataConverter) (*TrackInventoryRequest, *client.ScheduleDescription, error) {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return nil, nil, err
	}

	action, ok := desc.Schedule.Action.(*client.ScheduleWorkflowAction)
	if !ok {
		return nil, desc, fmt.Errorf("schedule %q action is not a workflow action", scheduleID)
	}
	if len(action.Args) == 0 {
		return nil, desc, fmt.Errorf("schedule %q has no input arguments", scheduleID)
	}
	payload, ok := action.Args[0].(*v1.Payload)
	if !ok {
		return nil, desc, fmt.Errorf("schedule %q input argument is not a raw payload (already decoded?)", scheduleID)
	}

	dc := converter.GetDefaultDataConverter()
	if len(dataConverter) > 0 && dataConverter[0] != nil {
		dc = dataConverter[0]
	}

	req := new(TrackInventoryRequest)
	if err := dc.FromPayload(payload, req); err != nil {
		return nil, desc, fmt.Errorf("decoding schedule %q input: %w", scheduleID, err)
	}
	return req, desc, nil
}

// DeleteScheduleTrackInventory deletes a schedule for TrackInventory
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) DeleteScheduleTrackInventory(ctx context.Context, scheduleID string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	return handle.Delete(ctx)
}

// PauseScheduleTrackInventory pauses a running schedule for TrackInventory. The note is
// recorded by Temporal on the schedule's audit trail (visible via Describe). If
// the schedule is already paused this is a no-op: we Describe first and skip the
// Pause API call when .Schedule.State.Paused is already true, so it's safe to
// call on every reconcile/bootstrap path without spamming the server.
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) PauseScheduleTrackInventory(ctx context.Context, scheduleID string, note string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return err
	}
	if desc.Schedule.State != nil && desc.Schedule.State.Paused {
		return nil
	}
	return handle.Pause(ctx, client.SchedulePauseOptions{Note: note})
}

// UnpauseScheduleTrackInventory resumes a paused schedule for TrackInventory. Like
// PauseScheduleTrackInventory, this is a read-then-write: we Describe first and
// return nil if the schedule is already running, so idempotent bootstrap code
// doesn't pay an extra Unpause round-trip per reconcile tick.
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) UnpauseScheduleTrackInventory(ctx context.Context, scheduleID string, note string) error {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)
	desc, err := handle.Describe(ctx)
	if err != nil {
		return err
	}
	if desc.Schedule.State == nil || !desc.Schedule.State.Paused {
		return nil
	}
	return handle.Unpause(ctx, client.ScheduleUnpauseOptions{Note: note})
}

// ListScheduleTrackInventory lists all schedules for TrackInventory workflow
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) ListScheduleTrackInventory(ctx context.Context, pageSize int) ([]client.ScheduleListEntry, error) {
	var schedules []client.ScheduleListEntry

	iter, err := c.client.ScheduleClient().List(ctx, client.ScheduleListOptions{
		PageSize: pageSize,
	})
	if err != nil {
		return nil, err
	}

	for iter.HasNext() {
		entry, err := iter.Next()
		if err != nil {
			return nil, err
		}

		// Filter by workflow type
		if entry.WorkflowType.Name == WorkflowTrackInventoryName {
			schedules = append(schedules, *entry)
		}
	}

	return schedules, nil
}

// UpsertScheduleTrackInventory creates or updates a schedule for TrackInventory
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
func (c *OrdersClient) UpsertScheduleTrackInventory(ctx context.Context, scheduleID string, req *TrackInventoryRequest, options ...client.ScheduleOptions) (client.ScheduleHandle, error) {
	handle := c.client.ScheduleClient().GetHandle(ctx, scheduleID)

	// Try to describe the schedule to see if it exists
	_, err := handle.Describe(ctx)
	if err != nil {
		// Schedule doesn't exist, create it
		return c.CreateScheduleTrackInventory(ctx, scheduleID, req, options...)
	}

	// Schedule exists, update it
	scheduleOptions := client.ScheduleOptions{
		ID: scheduleID,
		Action: &client.ScheduleWorkflowAction{
			ID:                       scheduleID,
			Workflow:                 WorkflowTrackInventoryName,
			Args:                     []interface{}{req},
			TaskQueue:                c.taskQueue,
			WorkflowExecutionTimeout: time.Duration(3600) * time.Second,
		},
	}

	if len(options) > 0 {
		// Upsert never flips Paused on a running schedule; everything else merges
		// identically to CreateSchedule.
		mergeScheduleOptionsOrders(&scheduleOptions, options[0], false)
	}
	applyScheduleDefaultsOrders(&scheduleOptions, DefaultOrdersTaskQueueName)

	// Update the schedule. The closure starts from the schedule as it exists on
	// the server (input.Description.Schedule) and overlays ONLY what the caller
	// supplied, so an upsert that just changes the request does not silently
	// blank the spec, drop search attributes, or reset sibling policy fields.
	err = handle.Update(ctx, client.ScheduleUpdateOptions{
		DoUpdate: func(input client.ScheduleUpdateInput) (*client.ScheduleUpdate, error) {
			schedule := input.Description.Schedule

			// Rebind the action so the updated request/args take effect.
			schedule.Action = scheduleOptions.Action

			// Only replace the spec when the caller supplied scheduling info;
			// otherwise keep the existing spec so the schedule keeps firing.
			if !scheduleSpecIsZeroOrders(scheduleOptions.Spec) {
				schedule.Spec = &scheduleOptions.Spec
			}

			// Merge policy fields onto the existing policy instead of replacing
			// it, so changing one field does not reset the others.
			if scheduleOptions.Overlap != 0 || scheduleOptions.CatchupWindow != 0 || scheduleOptions.PauseOnFailure {
				if schedule.Policy == nil {
					schedule.Policy = &client.SchedulePolicies{}
				}
				if scheduleOptions.Overlap != 0 {
					schedule.Policy.Overlap = scheduleOptions.Overlap
				}
				if scheduleOptions.CatchupWindow != 0 {
					schedule.Policy.CatchupWindow = scheduleOptions.CatchupWindow
				}
				if scheduleOptions.PauseOnFailure {
					schedule.Policy.PauseOnFailure = scheduleOptions.PauseOnFailure
				}
			}

			update := &client.ScheduleUpdate{Schedule: &schedule}
			// A nil pointer leaves the schedule's search attributes intact; only
			// send a non-empty set (an empty non-nil set removes all of them).
			if scheduleOptions.TypedSearchAttributes.Size() > 0 {
				update.TypedSearchAttributes = &scheduleOptions.TypedSearchAttributes
			}
			return update, nil
		},
	})
	if err != nil {
		return nil, err
	}

	return handle, nil
}

// mergeScheduleOptionsOrders merges user-supplied schedule options into the
// base struct built by the generated CreateSchedule/UpsertSchedule methods. Only
// non-zero fields on the user struct overwrite the base, so callers can pass a
// partial client.ScheduleOptions and keep whatever defaults the generator baked
// in. When applyPaused is true (the CreateSchedule flow) a user-supplied Paused
// flag is honoured so schedules can be created in the paused state. Upsert
// passes false: a bool can't distinguish "leave it alone" from "unpause me", so
// run-state transitions are handled out of band via the per-workflow
// PauseScheduleX / UnpauseScheduleX helpers rather than through the options
// struct.
func mergeScheduleOptionsOrders(base *client.ScheduleOptions, user client.ScheduleOptions, applyPaused bool) {
	if user.Spec.CronExpressions != nil {
		base.Spec.CronExpressions = user.Spec.CronExpressions
	}
	if user.Spec.Calendars != nil {
		base.Spec.Calendars = user.Spec.Calendars
	}
	if user.Spec.Intervals != nil {
		base.Spec.Intervals = user.Spec.Intervals
	}
	if user.Spec.Skip != nil {
		base.Spec.Skip = user.Spec.Skip
	}
	if !user.Spec.StartAt.IsZero() {
		base.Spec.StartAt = user.Spec.StartAt
	}
	if !user.Spec.EndAt.IsZero() {
		base.Spec.EndAt = user.Spec.EndAt
	}
	if user.Spec.Jitter != 0 {
		base.Spec.Jitter = user.Spec.Jitter
	}
	if user.Spec.TimeZoneName != "" {
		base.Spec.TimeZoneName = user.Spec.TimeZoneName
	}
	if user.TypedSearchAttributes.Size() > 0 {
		base.TypedSearchAttributes = user.TypedSearchAttributes
	}
	if user.Action != nil {
		base.Action = user.Action
	}
	if user.Note != "" {
		base.Note = user.Note
	}
	if user.Overlap != 0 {
		base.Overlap = user.Overlap
	}
	if user.CatchupWindow != 0 {
		base.CatchupWindow = user.CatchupWindow
	}
	if user.PauseOnFailure {
		base.PauseOnFailure = user.PauseOnFailure
	}
	if applyPaused && user.Paused {
		base.Paused = user.Paused
	}
}

// applyScheduleDefaultsOrders fills in the service's default task queue on
// the ScheduleWorkflowAction whenever the caller left TaskQueue empty. It runs
// after the merge helper so explicit caller input always wins over generator
// defaults.
func applyScheduleDefaultsOrders(opts *client.ScheduleOptions, defaultTaskQueue string) {
	if action, ok := opts.Action.(*client.ScheduleWorkflowAction); ok && action.TaskQueue == "" {
		action.TaskQueue = defaultTaskQueue
	}
}

// scheduleSpecIsZeroOrders reports whether a schedule spec carries no
// scheduling information, i.e. the caller supplied no spec. It checks exactly
// the fields that mergeScheduleOptionsOrders copies from user options, so
// "zero" here means "the caller did not provide a spec". UpsertSchedule uses it
// to avoid overwriting an existing schedule's spec with an empty one.
func scheduleSpecIsZeroOrders(spec client.ScheduleSpec) bool {
	return spec.CronExpressions == nil &&
		spec.Calendars == nil &&
		spec.Intervals == nil &&
		spec.Skip == nil &&
		spec.StartAt.IsZero() &&
		spec.EndAt.IsZero() &&
		spec.Jitter == 0 &&
		spec.TimeZoneName == ""
}

// ExecuteActivityChargePayment executes the activity asynchronously and returns a future to it
//
// ChargePayment captures the money. The retry policy retries transient
// payment provider hiccups with exponential backoff, but gives up
// immediately when the card is declined: "CardDeclined" is listed in
// non_retryable_error_types and the worker returns application errors of
// that type when the card is bad
func (c *OrdersClient) ExecuteActivityChargePayment(ctx workflow.Context, req *ChargePaymentRequest, options ...workflow.ActivityOptions) workflow.Future {
	var aOptions workflow.ActivityOptions

	if len(options) > 0 {
		aOptions = options[0]
	}

	if aOptions.TaskQueue == "" {
		aOptions.TaskQueue = c.taskQueue
	}

	if aOptions.TaskQueue == "" {
		aOptions.TaskQueue = DefaultOrdersTaskQueueName
	}

	// Apply timeout options
	if aOptions.StartToCloseTimeout == 0 {
		aOptions.StartToCloseTimeout = time.Duration(10) * time.Second
	}
	if aOptions.ScheduleToCloseTimeout == 0 {
		aOptions.ScheduleToCloseTimeout = time.Duration(300) * time.Second
	}

	// Apply retry policy
	if aOptions.RetryPolicy == nil {
		aOptions.RetryPolicy = &temporal.RetryPolicy{
			InitialInterval:    time.Duration(1) * time.Second,
			MaximumInterval:    time.Duration(10) * time.Second,
			BackoffCoefficient: 2,
			MaximumAttempts:    5,
			NonRetryableErrorTypes: []string{
				"CardDeclined",
			},
		}
	}

	return workflow.ExecuteActivity(workflow.WithActivityOptions(ctx, aOptions), ActivityChargePaymentName, req)
}

// ExecuteActivityChargePaymentSync executes the activity synchronously and returns the result when finished
//
// ChargePayment captures the money. The retry policy retries transient
// payment provider hiccups with exponential backoff, but gives up
// immediately when the card is declined: "CardDeclined" is listed in
// non_retryable_error_types and the worker returns application errors of
// that type when the card is bad
func (c *OrdersClient) ExecuteActivityChargePaymentSync(ctx workflow.Context, req *ChargePaymentRequest, options ...workflow.ActivityOptions) (*ChargePaymentResponse, error) {
	future := c.ExecuteActivityChargePayment(ctx, req, options...)

	var resp *ChargePaymentResponse
	err := future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ExecuteActivityPackItems executes the activity asynchronously and returns a future to it
//
// PackItems packs the order, one parcel per item. It is slow, so it
// records a heartbeat after every parcel: if the worker dies mid-pack,
// Temporal notices within heartbeat_timeout and reschedules the activity
func (c *OrdersClient) ExecuteActivityPackItems(ctx workflow.Context, req *PackItemsRequest, options ...workflow.ActivityOptions) workflow.Future {
	var aOptions workflow.ActivityOptions

	if len(options) > 0 {
		aOptions = options[0]
	}

	if aOptions.TaskQueue == "" {
		aOptions.TaskQueue = c.taskQueue
	}

	if aOptions.TaskQueue == "" {
		aOptions.TaskQueue = DefaultOrdersTaskQueueName
	}

	// Apply timeout options
	if aOptions.StartToCloseTimeout == 0 {
		aOptions.StartToCloseTimeout = time.Duration(60) * time.Second
	}
	if aOptions.ScheduleToCloseTimeout == 0 {
		aOptions.ScheduleToCloseTimeout = time.Duration(300) * time.Second
	}
	if aOptions.HeartbeatTimeout == 0 {
		aOptions.HeartbeatTimeout = time.Duration(10) * time.Second
	}

	return workflow.ExecuteActivity(workflow.WithActivityOptions(ctx, aOptions), ActivityPackItemsName, req)
}

// ExecuteActivityPackItemsSync executes the activity synchronously and returns the result when finished
//
// PackItems packs the order, one parcel per item. It is slow, so it
// records a heartbeat after every parcel: if the worker dies mid-pack,
// Temporal notices within heartbeat_timeout and reschedules the activity
func (c *OrdersClient) ExecuteActivityPackItemsSync(ctx workflow.Context, req *PackItemsRequest, options ...workflow.ActivityOptions) (*PackItemsResponse, error) {
	future := c.ExecuteActivityPackItems(ctx, req, options...)

	var resp *PackItemsResponse
	err := future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ExecuteActivityDispatchCourier executes the activity asynchronously and returns a future to it
//
// DispatchCourier books a courier and returns a tracking number. The
// `name` option overrides the registered activity name, which otherwise
// defaults to <package>.<service>.<method>
func (c *OrdersClient) ExecuteActivityDispatchCourier(ctx workflow.Context, req *DispatchCourierRequest, options ...workflow.ActivityOptions) workflow.Future {
	var aOptions workflow.ActivityOptions

	if len(options) > 0 {
		aOptions = options[0]
	}

	if aOptions.TaskQueue == "" {
		aOptions.TaskQueue = c.taskQueue
	}

	if aOptions.TaskQueue == "" {
		aOptions.TaskQueue = DefaultOrdersTaskQueueName
	}

	// Apply timeout options
	if aOptions.StartToCloseTimeout == 0 {
		aOptions.StartToCloseTimeout = time.Duration(30) * time.Second
	}
	if aOptions.ScheduleToCloseTimeout == 0 {
		aOptions.ScheduleToCloseTimeout = time.Duration(300) * time.Second
	}

	return workflow.ExecuteActivity(workflow.WithActivityOptions(ctx, aOptions), ActivityDispatchCourierName, req)
}

// ExecuteActivityDispatchCourierSync executes the activity synchronously and returns the result when finished
//
// DispatchCourier books a courier and returns a tracking number. The
// `name` option overrides the registered activity name, which otherwise
// defaults to <package>.<service>.<method>
func (c *OrdersClient) ExecuteActivityDispatchCourierSync(ctx workflow.Context, req *DispatchCourierRequest, options ...workflow.ActivityOptions) (*DispatchCourierResponse, error) {
	future := c.ExecuteActivityDispatchCourier(ctx, req, options...)

	var resp *DispatchCourierResponse
	err := future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// OrdersWorker Worker for the Orders service
type OrdersWorker struct {
	client client.Client
	worker worker.Worker
	svc    OrdersService
}

// NewOrdersWorker Returns a new instance of the worker.
// If `taskQueue` stays empty the default one will be used
func NewOrdersWorker(client client.Client, svc OrdersService, taskQueue string, workerOptions ...worker.Options) (*OrdersWorker, error) {
	wOpts := worker.Options{}
	if taskQueue == "" {
		taskQueue = DefaultOrdersTaskQueueName
	}
	if len(workerOptions) > 0 {
		wOpts = workerOptions[0]
	}
	w := worker.New(client, taskQueue, wOpts)

	return &OrdersWorker{
		client: client,
		svc:    svc,
		worker: w,
	}, nil
}

// Register registers the worker's activities and workflows with Temporal.
func (w *OrdersWorker) Register() {
	// Registers activity ChargePayment
	w.worker.RegisterActivityWithOptions(w.svc.ChargePayment, activity.RegisterOptions{
		Name: ActivityChargePaymentName,
	})
	// Registers activity PackItems
	w.worker.RegisterActivityWithOptions(w.svc.PackItems, activity.RegisterOptions{
		Name: ActivityPackItemsName,
	})
	// Registers activity DispatchCourier
	w.worker.RegisterActivityWithOptions(w.svc.DispatchCourier, activity.RegisterOptions{
		Name: ActivityDispatchCourierName,
	})
	// Registers workflow ProcessOrder
	w.worker.RegisterWorkflowWithOptions(w.svc.ProcessOrder, workflow.RegisterOptions{
		Name: WorkflowProcessOrderName,
	})
	// Registers workflow ShipOrder
	w.worker.RegisterWorkflowWithOptions(w.svc.ShipOrder, workflow.RegisterOptions{
		Name: WorkflowShipOrderName,
	})
	// Registers workflow DailySalesReport
	w.worker.RegisterWorkflowWithOptions(w.svc.DailySalesReport, workflow.RegisterOptions{
		Name: WorkflowDailySalesReportName,
	})
	// Registers workflow TrackInventory
	w.worker.RegisterWorkflowWithOptions(w.svc.TrackInventory, workflow.RegisterOptions{
		Name: WorkflowTrackInventoryName,
	})
}

// Start runs the worker in a non-blocking fashion. Use Stop() to stop it.
func (w *OrdersWorker) Start() error {
	return w.worker.Start()
}

// Run runs the worker until interruptCh receives a signal. Use worker.InterruptCh() to wire up an OS interrupt signal.
func (w *OrdersWorker) Run(interruptCh <-chan any) error {
	return w.worker.Run(interruptCh)
}

// Stop stops the worker. It may panic if called twice.
func (w *OrdersWorker) Stop() {
	w.worker.Stop()
}

// OrdersProcessOrder is a struct that wraps a workflow
//
// ProcessOrder drives an order from payment to shipping. While it runs it
// can be queried (GetOrderStatus), updated (ChangeShippingAddress) and
// cancelled (CancelOrder signal)
type OrdersProcessOrder struct {
	client     client.Client
	future     client.WorkflowRun
	workflowId string
	runId      string
}

// GetProcessOrder gets an instance of a given workflow
func (c *OrdersClient) GetProcessOrder(ctx context.Context, workflowId string, runId string) *OrdersProcessOrder {
	future := c.client.GetWorkflow(ctx, workflowId, runId)

	return &OrdersProcessOrder{
		client:     c.client,
		future:     future,
		workflowId: workflowId,
		runId:      runId,
	}
}

// GetProcessOrderFromRun gets an instance of a given workflow from a future
func (c *OrdersClient) GetProcessOrderFromRun(future client.WorkflowRun) *OrdersProcessOrder {
	return &OrdersProcessOrder{
		workflowId: future.GetID(),
		runId:      future.GetRunID(),
		client:     c.client,
		future:     future,
	}
}

// Cancel cancels a given workflow
func (w *OrdersProcessOrder) Cancel(ctx context.Context) error {
	return w.client.CancelWorkflow(ctx, w.workflowId, w.runId)
}

// GetID Returns the workflow ID
func (w *OrdersProcessOrder) GetID() string {
	return w.future.GetID()
}

// GetRunID Returns the run ID
func (w *OrdersProcessOrder) GetRunID() string {
	return w.future.GetRunID()
}

// Terminate terminates a given workflow
func (w *OrdersProcessOrder) Terminate(ctx context.Context, reason string, details ...interface{}) error {
	return w.client.TerminateWorkflow(ctx, w.workflowId, w.runId, reason, details...)
}

// Result gets the result of a given workflow with its native type
func (w *OrdersProcessOrder) Result(ctx context.Context) (*ProcessOrderResponse, error) {
	var resp *ProcessOrderResponse

	err := w.future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ResultWithOptions gets the result of a given workflow with its native type
func (w *OrdersProcessOrder) ResultWithOptions(ctx context.Context, options client.WorkflowRunGetOptions) (*ProcessOrderResponse, error) {
	var resp *ProcessOrderResponse

	err := w.future.GetWithOptions(ctx, &resp, options)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Get gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.WorkflowRun
func (w *OrdersProcessOrder) Get(ctx context.Context, valuePtr interface{}) error {
	return w.future.Get(ctx, valuePtr)
}

// GetWithOptions gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.WorkflowRun
func (w *OrdersProcessOrder) GetWithOptions(ctx context.Context, valuePtr interface{}, options client.WorkflowRunGetOptions) error {
	return w.future.GetWithOptions(ctx, valuePtr, options)
}

// SignalCancelOrder sends the CancelOrder signal to the workflow
func (w *OrdersProcessOrder) SignalCancelOrder(ctx context.Context, req *CancelOrderRequest) error {
	return w.client.SignalWorkflow(ctx, w.future.GetID(), w.future.GetRunID(), SignalCancelOrderName, req)
}

// QueryGetOrderStatus queries the workflow with GetOrderStatus
func (w *OrdersProcessOrder) QueryGetOrderStatus(ctx context.Context, req *emptypb.Empty) (*GetOrderStatusResponse, error) {
	future, err := w.client.QueryWorkflow(ctx, w.future.GetID(), w.future.GetRunID(), QueryGetOrderStatusName, req)
	if err != nil {
		return nil, err
	}

	var resp *GetOrderStatusResponse
	err = future.Get(&resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// UpdateChangeShippingAddress sends the ChangeShippingAddress update to the workflow and waits for it to complete
func (w *OrdersProcessOrder) UpdateChangeShippingAddress(ctx context.Context, req *ChangeShippingAddressRequest) (*ChangeShippingAddressResponse, error) {
	handle, err := w.client.UpdateWorkflow(ctx, client.UpdateWorkflowOptions{
		WorkflowID:   w.future.GetID(),
		RunID:        w.future.GetRunID(),
		UpdateName:   UpdateChangeShippingAddressName,
		Args:         []interface{}{req},
		WaitForStage: client.WorkflowUpdateStageCompleted,
	})
	if err != nil {
		return nil, err
	}

	var resp *ChangeShippingAddressResponse
	err = handle.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ChildOrdersProcessOrderExecution is a struct that wraps a workflow execution (called from another workflow)
type ChildOrdersProcessOrderExecution struct {
	client client.Client
	future workflow.ChildWorkflowFuture
}

// GetChildOrdersProcessOrderExecution gets an instance of a given workflow from a future
func (c *OrdersClient) GetChildOrdersProcessOrderExecution(future workflow.ChildWorkflowFuture) *ChildOrdersProcessOrderExecution {
	return &ChildOrdersProcessOrderExecution{
		client: c.client,
		future: future,
	}
}

// Result gets the result of a given workflow with its native type
func (w *ChildOrdersProcessOrderExecution) Result(ctx workflow.Context) (*ProcessOrderResponse, error) {
	var resp *ProcessOrderResponse

	err := w.future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Get gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.Future
func (w *ChildOrdersProcessOrderExecution) Get(ctx workflow.Context, valuePtr interface{}) error {
	return w.future.Get(ctx, valuePtr)
}

// GetChildWorkflowExecution Wraps the GetChildWorkflowExecution and returns an workflow.Future
func (w *ChildOrdersProcessOrderExecution) GetChildWorkflowExecution() workflow.Future {
	return w.future
}

// IsReady Wraps the IsReady method from the future
func (w *ChildOrdersProcessOrderExecution) IsReady() bool {
	return w.future.IsReady()
}

// SignalChildWorkflow Signals the child workflow with a generic signal -- discouraged to use but required to implement internal.Future
func (w *ChildOrdersProcessOrderExecution) SignalChildWorkflow(ctx workflow.Context, sigName string, data interface{}) workflow.Future {
	return w.future.SignalChildWorkflow(ctx, sigName, data)
}

// SignalCancelOrder sends the CancelOrder signal to the workflow
func (w *ChildOrdersProcessOrderExecution) SignalCancelOrder(ctx workflow.Context, req *CancelOrderRequest) error {
	return w.future.SignalChildWorkflow(ctx, SignalCancelOrderName, req).Get(ctx, nil)
}

// OrdersShipOrder is a struct that wraps a workflow
//
// ShipOrder hands the package over to a courier. ProcessOrder runs it as a
// child workflow so shipping shows up as its own execution in the UI
type OrdersShipOrder struct {
	client     client.Client
	future     client.WorkflowRun
	workflowId string
	runId      string
}

// GetShipOrder gets an instance of a given workflow
func (c *OrdersClient) GetShipOrder(ctx context.Context, workflowId string, runId string) *OrdersShipOrder {
	future := c.client.GetWorkflow(ctx, workflowId, runId)

	return &OrdersShipOrder{
		client:     c.client,
		future:     future,
		workflowId: workflowId,
		runId:      runId,
	}
}

// GetShipOrderFromRun gets an instance of a given workflow from a future
func (c *OrdersClient) GetShipOrderFromRun(future client.WorkflowRun) *OrdersShipOrder {
	return &OrdersShipOrder{
		workflowId: future.GetID(),
		runId:      future.GetRunID(),
		client:     c.client,
		future:     future,
	}
}

// Cancel cancels a given workflow
func (w *OrdersShipOrder) Cancel(ctx context.Context) error {
	return w.client.CancelWorkflow(ctx, w.workflowId, w.runId)
}

// GetID Returns the workflow ID
func (w *OrdersShipOrder) GetID() string {
	return w.future.GetID()
}

// GetRunID Returns the run ID
func (w *OrdersShipOrder) GetRunID() string {
	return w.future.GetRunID()
}

// Terminate terminates a given workflow
func (w *OrdersShipOrder) Terminate(ctx context.Context, reason string, details ...interface{}) error {
	return w.client.TerminateWorkflow(ctx, w.workflowId, w.runId, reason, details...)
}

// Result gets the result of a given workflow with its native type
func (w *OrdersShipOrder) Result(ctx context.Context) (*ShipOrderResponse, error) {
	var resp *ShipOrderResponse

	err := w.future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ResultWithOptions gets the result of a given workflow with its native type
func (w *OrdersShipOrder) ResultWithOptions(ctx context.Context, options client.WorkflowRunGetOptions) (*ShipOrderResponse, error) {
	var resp *ShipOrderResponse

	err := w.future.GetWithOptions(ctx, &resp, options)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Get gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.WorkflowRun
func (w *OrdersShipOrder) Get(ctx context.Context, valuePtr interface{}) error {
	return w.future.Get(ctx, valuePtr)
}

// GetWithOptions gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.WorkflowRun
func (w *OrdersShipOrder) GetWithOptions(ctx context.Context, valuePtr interface{}, options client.WorkflowRunGetOptions) error {
	return w.future.GetWithOptions(ctx, valuePtr, options)
}

// ChildOrdersShipOrderExecution is a struct that wraps a workflow execution (called from another workflow)
type ChildOrdersShipOrderExecution struct {
	client client.Client
	future workflow.ChildWorkflowFuture
}

// GetChildOrdersShipOrderExecution gets an instance of a given workflow from a future
func (c *OrdersClient) GetChildOrdersShipOrderExecution(future workflow.ChildWorkflowFuture) *ChildOrdersShipOrderExecution {
	return &ChildOrdersShipOrderExecution{
		client: c.client,
		future: future,
	}
}

// Result gets the result of a given workflow with its native type
func (w *ChildOrdersShipOrderExecution) Result(ctx workflow.Context) (*ShipOrderResponse, error) {
	var resp *ShipOrderResponse

	err := w.future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Get gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.Future
func (w *ChildOrdersShipOrderExecution) Get(ctx workflow.Context, valuePtr interface{}) error {
	return w.future.Get(ctx, valuePtr)
}

// GetChildWorkflowExecution Wraps the GetChildWorkflowExecution and returns an workflow.Future
func (w *ChildOrdersShipOrderExecution) GetChildWorkflowExecution() workflow.Future {
	return w.future
}

// IsReady Wraps the IsReady method from the future
func (w *ChildOrdersShipOrderExecution) IsReady() bool {
	return w.future.IsReady()
}

// SignalChildWorkflow Signals the child workflow with a generic signal -- discouraged to use but required to implement internal.Future
func (w *ChildOrdersShipOrderExecution) SignalChildWorkflow(ctx workflow.Context, sigName string, data interface{}) workflow.Future {
	return w.future.SignalChildWorkflow(ctx, sigName, data)
}

// OrdersDailySalesReport is a struct that wraps a workflow
//
// DailySalesReport is a fast workflow meant to be driven by a Temporal
// schedule -- see the schedule part of the client walkthrough
type OrdersDailySalesReport struct {
	client     client.Client
	future     client.WorkflowRun
	workflowId string
	runId      string
}

// GetDailySalesReport gets an instance of a given workflow
func (c *OrdersClient) GetDailySalesReport(ctx context.Context, workflowId string, runId string) *OrdersDailySalesReport {
	future := c.client.GetWorkflow(ctx, workflowId, runId)

	return &OrdersDailySalesReport{
		client:     c.client,
		future:     future,
		workflowId: workflowId,
		runId:      runId,
	}
}

// GetDailySalesReportFromRun gets an instance of a given workflow from a future
func (c *OrdersClient) GetDailySalesReportFromRun(future client.WorkflowRun) *OrdersDailySalesReport {
	return &OrdersDailySalesReport{
		workflowId: future.GetID(),
		runId:      future.GetRunID(),
		client:     c.client,
		future:     future,
	}
}

// Cancel cancels a given workflow
func (w *OrdersDailySalesReport) Cancel(ctx context.Context) error {
	return w.client.CancelWorkflow(ctx, w.workflowId, w.runId)
}

// GetID Returns the workflow ID
func (w *OrdersDailySalesReport) GetID() string {
	return w.future.GetID()
}

// GetRunID Returns the run ID
func (w *OrdersDailySalesReport) GetRunID() string {
	return w.future.GetRunID()
}

// Terminate terminates a given workflow
func (w *OrdersDailySalesReport) Terminate(ctx context.Context, reason string, details ...interface{}) error {
	return w.client.TerminateWorkflow(ctx, w.workflowId, w.runId, reason, details...)
}

// Result gets the result of a given workflow with its native type
func (w *OrdersDailySalesReport) Result(ctx context.Context) (*DailySalesReportResponse, error) {
	var resp *DailySalesReportResponse

	err := w.future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ResultWithOptions gets the result of a given workflow with its native type
func (w *OrdersDailySalesReport) ResultWithOptions(ctx context.Context, options client.WorkflowRunGetOptions) (*DailySalesReportResponse, error) {
	var resp *DailySalesReportResponse

	err := w.future.GetWithOptions(ctx, &resp, options)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Get gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.WorkflowRun
func (w *OrdersDailySalesReport) Get(ctx context.Context, valuePtr interface{}) error {
	return w.future.Get(ctx, valuePtr)
}

// GetWithOptions gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.WorkflowRun
func (w *OrdersDailySalesReport) GetWithOptions(ctx context.Context, valuePtr interface{}, options client.WorkflowRunGetOptions) error {
	return w.future.GetWithOptions(ctx, valuePtr, options)
}

// ChildOrdersDailySalesReportExecution is a struct that wraps a workflow execution (called from another workflow)
type ChildOrdersDailySalesReportExecution struct {
	client client.Client
	future workflow.ChildWorkflowFuture
}

// GetChildOrdersDailySalesReportExecution gets an instance of a given workflow from a future
func (c *OrdersClient) GetChildOrdersDailySalesReportExecution(future workflow.ChildWorkflowFuture) *ChildOrdersDailySalesReportExecution {
	return &ChildOrdersDailySalesReportExecution{
		client: c.client,
		future: future,
	}
}

// Result gets the result of a given workflow with its native type
func (w *ChildOrdersDailySalesReportExecution) Result(ctx workflow.Context) (*DailySalesReportResponse, error) {
	var resp *DailySalesReportResponse

	err := w.future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Get gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.Future
func (w *ChildOrdersDailySalesReportExecution) Get(ctx workflow.Context, valuePtr interface{}) error {
	return w.future.Get(ctx, valuePtr)
}

// GetChildWorkflowExecution Wraps the GetChildWorkflowExecution and returns an workflow.Future
func (w *ChildOrdersDailySalesReportExecution) GetChildWorkflowExecution() workflow.Future {
	return w.future
}

// IsReady Wraps the IsReady method from the future
func (w *ChildOrdersDailySalesReportExecution) IsReady() bool {
	return w.future.IsReady()
}

// SignalChildWorkflow Signals the child workflow with a generic signal -- discouraged to use but required to implement internal.Future
func (w *ChildOrdersDailySalesReportExecution) SignalChildWorkflow(ctx workflow.Context, sigName string, data interface{}) workflow.Future {
	return w.future.SignalChildWorkflow(ctx, sigName, data)
}

// OrdersTrackInventory is a struct that wraps a workflow
//
// TrackInventory is a long-lived "entity" workflow tracking the stock of
// one SKU. It rolls over with continue-as-new after a number of restocks,
// which makes it the demo for how BLOCKED updates interact with
// continue-as-new: the workflow drains its update handlers (see
// workflow.AllHandlersFinished) before rolling over, so a Reserve update
// parked on "not enough stock" is answered before the run ends
type OrdersTrackInventory struct {
	client     client.Client
	future     client.WorkflowRun
	workflowId string
	runId      string
}

// GetTrackInventory gets an instance of a given workflow
func (c *OrdersClient) GetTrackInventory(ctx context.Context, workflowId string, runId string) *OrdersTrackInventory {
	future := c.client.GetWorkflow(ctx, workflowId, runId)

	return &OrdersTrackInventory{
		client:     c.client,
		future:     future,
		workflowId: workflowId,
		runId:      runId,
	}
}

// GetTrackInventoryFromRun gets an instance of a given workflow from a future
func (c *OrdersClient) GetTrackInventoryFromRun(future client.WorkflowRun) *OrdersTrackInventory {
	return &OrdersTrackInventory{
		workflowId: future.GetID(),
		runId:      future.GetRunID(),
		client:     c.client,
		future:     future,
	}
}

// Cancel cancels a given workflow
func (w *OrdersTrackInventory) Cancel(ctx context.Context) error {
	return w.client.CancelWorkflow(ctx, w.workflowId, w.runId)
}

// GetID Returns the workflow ID
func (w *OrdersTrackInventory) GetID() string {
	return w.future.GetID()
}

// GetRunID Returns the run ID
func (w *OrdersTrackInventory) GetRunID() string {
	return w.future.GetRunID()
}

// Terminate terminates a given workflow
func (w *OrdersTrackInventory) Terminate(ctx context.Context, reason string, details ...interface{}) error {
	return w.client.TerminateWorkflow(ctx, w.workflowId, w.runId, reason, details...)
}

// Result gets the result of a given workflow with its native type
func (w *OrdersTrackInventory) Result(ctx context.Context) (*GetStockResponse, error) {
	var resp *GetStockResponse

	err := w.future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ResultWithOptions gets the result of a given workflow with its native type
func (w *OrdersTrackInventory) ResultWithOptions(ctx context.Context, options client.WorkflowRunGetOptions) (*GetStockResponse, error) {
	var resp *GetStockResponse

	err := w.future.GetWithOptions(ctx, &resp, options)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Get gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.WorkflowRun
func (w *OrdersTrackInventory) Get(ctx context.Context, valuePtr interface{}) error {
	return w.future.Get(ctx, valuePtr)
}

// GetWithOptions gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.WorkflowRun
func (w *OrdersTrackInventory) GetWithOptions(ctx context.Context, valuePtr interface{}, options client.WorkflowRunGetOptions) error {
	return w.future.GetWithOptions(ctx, valuePtr, options)
}

// SignalRestock sends the Restock signal to the workflow
func (w *OrdersTrackInventory) SignalRestock(ctx context.Context, req *RestockRequest) error {
	return w.client.SignalWorkflow(ctx, w.future.GetID(), w.future.GetRunID(), SignalRestockName, req)
}

// QueryGetStock queries the workflow with GetStock
func (w *OrdersTrackInventory) QueryGetStock(ctx context.Context, req *emptypb.Empty) (*GetStockResponse, error) {
	future, err := w.client.QueryWorkflow(ctx, w.future.GetID(), w.future.GetRunID(), QueryGetStockName, req)
	if err != nil {
		return nil, err
	}

	var resp *GetStockResponse
	err = future.Get(&resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// UpdateReserve sends the Reserve update to the workflow and waits for it to complete
func (w *OrdersTrackInventory) UpdateReserve(ctx context.Context, req *ReserveRequest) (*ReserveResponse, error) {
	handle, err := w.client.UpdateWorkflow(ctx, client.UpdateWorkflowOptions{
		WorkflowID:   w.future.GetID(),
		RunID:        w.future.GetRunID(),
		UpdateName:   UpdateReserveName,
		Args:         []interface{}{req},
		WaitForStage: client.WorkflowUpdateStageCompleted,
	})
	if err != nil {
		return nil, err
	}

	var resp *ReserveResponse
	err = handle.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// ChildOrdersTrackInventoryExecution is a struct that wraps a workflow execution (called from another workflow)
type ChildOrdersTrackInventoryExecution struct {
	client client.Client
	future workflow.ChildWorkflowFuture
}

// GetChildOrdersTrackInventoryExecution gets an instance of a given workflow from a future
func (c *OrdersClient) GetChildOrdersTrackInventoryExecution(future workflow.ChildWorkflowFuture) *ChildOrdersTrackInventoryExecution {
	return &ChildOrdersTrackInventoryExecution{
		client: c.client,
		future: future,
	}
}

// Result gets the result of a given workflow with its native type
func (w *ChildOrdersTrackInventoryExecution) Result(ctx workflow.Context) (*GetStockResponse, error) {
	var resp *GetStockResponse

	err := w.future.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// Get gets the result of a given workflow with pointers -- discouraged to use but required to implement internal.Future
func (w *ChildOrdersTrackInventoryExecution) Get(ctx workflow.Context, valuePtr interface{}) error {
	return w.future.Get(ctx, valuePtr)
}

// GetChildWorkflowExecution Wraps the GetChildWorkflowExecution and returns an workflow.Future
func (w *ChildOrdersTrackInventoryExecution) GetChildWorkflowExecution() workflow.Future {
	return w.future
}

// IsReady Wraps the IsReady method from the future
func (w *ChildOrdersTrackInventoryExecution) IsReady() bool {
	return w.future.IsReady()
}

// SignalChildWorkflow Signals the child workflow with a generic signal -- discouraged to use but required to implement internal.Future
func (w *ChildOrdersTrackInventoryExecution) SignalChildWorkflow(ctx workflow.Context, sigName string, data interface{}) workflow.Future {
	return w.future.SignalChildWorkflow(ctx, sigName, data)
}

// SignalRestock sends the Restock signal to the workflow
func (w *ChildOrdersTrackInventoryExecution) SignalRestock(ctx workflow.Context, req *RestockRequest) error {
	return w.future.SignalChildWorkflow(ctx, SignalRestockName, req).Get(ctx, nil)
}

// SendSignalCancelOrder sends the CancelOrder signal to a workflow
//
// CancelOrder asks a running ProcessOrder workflow to stop. Signals are
// fire and forget: the response type of a signal rpc is ignored by the
// generator
func (c *OrdersClient) SendSignalCancelOrder(ctx context.Context, workflowID string, runID string, req *CancelOrderRequest) error {
	return c.client.SignalWorkflow(ctx, workflowID, runID, SignalCancelOrderName, req)
}

// ReceiveSignalCancelOrder blocks until the CancelOrder signal is received. The
// returned bool reports whether the receive succeeded; because Temporal signal
// channels are never closed it is effectively always true here. Use
// ReceiveSignalCancelOrderAsync if you need a meaningful "was anything queued" bool.
//
// CancelOrder asks a running ProcessOrder workflow to stop. Signals are
// fire and forget: the response type of a signal rpc is ignored by the
// generator
func ReceiveSignalCancelOrder(ctx workflow.Context) (*CancelOrderRequest, bool) {
	var result *CancelOrderRequest
	ok := workflow.GetSignalChannel(ctx, SignalCancelOrderName).Receive(ctx, &result)
	return result, ok
}

// ReceiveSignalCancelOrderAsync receives the CancelOrder signal asynchronously. It doesn't wait if there is no signal in the queue
//
// CancelOrder asks a running ProcessOrder workflow to stop. Signals are
// fire and forget: the response type of a signal rpc is ignored by the
// generator
func ReceiveSignalCancelOrderAsync(ctx workflow.Context) (*CancelOrderRequest, bool) {
	var result *CancelOrderRequest
	ok := workflow.GetSignalChannel(ctx, SignalCancelOrderName).ReceiveAsync(&result)
	return result, ok
}

// SendSignalRestock sends the Restock signal to a workflow
//
// Restock adds stock to a running TrackInventory workflow. Fire and forget
func (c *OrdersClient) SendSignalRestock(ctx context.Context, workflowID string, runID string, req *RestockRequest) error {
	return c.client.SignalWorkflow(ctx, workflowID, runID, SignalRestockName, req)
}

// ReceiveSignalRestock blocks until the Restock signal is received. The
// returned bool reports whether the receive succeeded; because Temporal signal
// channels are never closed it is effectively always true here. Use
// ReceiveSignalRestockAsync if you need a meaningful "was anything queued" bool.
//
// Restock adds stock to a running TrackInventory workflow. Fire and forget
func ReceiveSignalRestock(ctx workflow.Context) (*RestockRequest, bool) {
	var result *RestockRequest
	ok := workflow.GetSignalChannel(ctx, SignalRestockName).Receive(ctx, &result)
	return result, ok
}

// ReceiveSignalRestockAsync receives the Restock signal asynchronously. It doesn't wait if there is no signal in the queue
//
// Restock adds stock to a running TrackInventory workflow. Fire and forget
func ReceiveSignalRestockAsync(ctx workflow.Context) (*RestockRequest, bool) {
	var result *RestockRequest
	ok := workflow.GetSignalChannel(ctx, SignalRestockName).ReceiveAsync(&result)
	return result, ok
}

// QueryGetOrderStatus sends the GetOrderStatus query to a workflow
//
// GetOrderStatus reads the current state of an order without touching it.
// Queries are read only and are answered even after the workflow
// completed, as long as a worker is running
func (c *OrdersClient) QueryGetOrderStatus(ctx context.Context, workflowID string, runID string, req *emptypb.Empty) (*GetOrderStatusResponse, error) {
	future, err := c.client.QueryWorkflow(ctx, workflowID, runID, QueryGetOrderStatusName, req)
	if err != nil {
		return nil, err
	}

	var resp *GetOrderStatusResponse
	err = future.Get(&resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// HandleQueryGetOrderStatus sets up the GetOrderStatus query and responds accordingly, returns an error if it failed
//
// GetOrderStatus reads the current state of an order without touching it.
// Queries are read only and are answered even after the workflow
// completed, as long as a worker is running
func HandleQueryGetOrderStatus(ctx workflow.Context, queryFunc func(req *emptypb.Empty) (*GetOrderStatusResponse, error)) error {
	return workflow.SetQueryHandler(ctx, QueryGetOrderStatusName, queryFunc)
}

// QueryGetStock sends the GetStock query to a workflow
//
// GetStock reads the current stock of a running (or finished)
// TrackInventory workflow
func (c *OrdersClient) QueryGetStock(ctx context.Context, workflowID string, runID string, req *emptypb.Empty) (*GetStockResponse, error) {
	future, err := c.client.QueryWorkflow(ctx, workflowID, runID, QueryGetStockName, req)
	if err != nil {
		return nil, err
	}

	var resp *GetStockResponse
	err = future.Get(&resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// HandleQueryGetStock sets up the GetStock query and responds accordingly, returns an error if it failed
//
// GetStock reads the current stock of a running (or finished)
// TrackInventory workflow
func HandleQueryGetStock(ctx workflow.Context, queryFunc func(req *emptypb.Empty) (*GetStockResponse, error)) error {
	return workflow.SetQueryHandler(ctx, QueryGetStockName, queryFunc)
}

// UpdateChangeShippingAddress sends the ChangeShippingAddress update to a workflow and ALWAYS blocks until
// the handler returned, yielding the typed result: the update handle is waited on
// regardless of WaitForStage, so this helper cannot be used fire-and-forget.
// Options are mainly useful for setting an UpdateID (idempotency) or
// FirstExecutionRunID; WaitForStage defaults to WorkflowUpdateStageCompleted when
// unspecified, and overriding it only changes how much is guaranteed to have
// happened before the underlying UpdateWorkflow call returns internally
//
// ChangeShippingAddress is an update: a synchronous request/response
// against the running workflow. The caller blocks until the handler
// answers, and a validator rejects garbage before it ever reaches the
// workflow history
func (c *OrdersClient) UpdateChangeShippingAddress(ctx context.Context, workflowID string, runID string, req *ChangeShippingAddressRequest, options ...client.UpdateWorkflowOptions) (*ChangeShippingAddressResponse, error) {
	uOptions := client.UpdateWorkflowOptions{}
	if len(options) > 0 {
		uOptions = options[0]
	}
	uOptions.WorkflowID = workflowID
	uOptions.RunID = runID
	uOptions.UpdateName = UpdateChangeShippingAddressName
	uOptions.Args = []interface{}{req}
	if uOptions.WaitForStage == client.WorkflowUpdateStageUnspecified {
		uOptions.WaitForStage = client.WorkflowUpdateStageCompleted
	}

	handle, err := c.client.UpdateWorkflow(ctx, uOptions)
	if err != nil {
		return nil, err
	}

	var resp *ChangeShippingAddressResponse
	err = handle.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// HandleUpdateChangeShippingAddress sets up the ChangeShippingAddress update handler, returns an error if it failed
//
// ChangeShippingAddress is an update: a synchronous request/response
// against the running workflow. The caller blocks until the handler
// answers, and a validator rejects garbage before it ever reaches the
// workflow history
func HandleUpdateChangeShippingAddress(ctx workflow.Context, updateFunc func(ctx workflow.Context, req *ChangeShippingAddressRequest) (*ChangeShippingAddressResponse, error)) error {
	return workflow.SetUpdateHandler(ctx, UpdateChangeShippingAddressName, updateFunc)
}

// HandleUpdateChangeShippingAddressWithValidator sets up the ChangeShippingAddress update handler with a
// validator. The validator runs before the update is admitted to history; if it
// returns a non-nil error the update is rejected and never recorded
//
// ChangeShippingAddress is an update: a synchronous request/response
// against the running workflow. The caller blocks until the handler
// answers, and a validator rejects garbage before it ever reaches the
// workflow history
func HandleUpdateChangeShippingAddressWithValidator(ctx workflow.Context, updateFunc func(ctx workflow.Context, req *ChangeShippingAddressRequest) (*ChangeShippingAddressResponse, error), validatorFunc func(ctx workflow.Context, req *ChangeShippingAddressRequest) error) error {
	return workflow.SetUpdateHandlerWithOptions(ctx, UpdateChangeShippingAddressName, updateFunc, workflow.UpdateHandlerOptions{
		Validator: validatorFunc,
	})
}

// UpdateReserve sends the Reserve update to a workflow and ALWAYS blocks until
// the handler returned, yielding the typed result: the update handle is waited on
// regardless of WaitForStage, so this helper cannot be used fire-and-forget.
// Options are mainly useful for setting an UpdateID (idempotency) or
// FirstExecutionRunID; WaitForStage defaults to WorkflowUpdateStageCompleted when
// unspecified, and overriding it only changes how much is guaranteed to have
// happened before the underlying UpdateWorkflow call returns internally
//
// Reserve takes stock out of a TrackInventory workflow. This is a BLOCKING
// update: if there is not enough stock the handler parks on workflow.Await
// until a Restock signal makes the quantity available, and only then
// answers the caller. This is the lease/semaphore pattern
func (c *OrdersClient) UpdateReserve(ctx context.Context, workflowID string, runID string, req *ReserveRequest, options ...client.UpdateWorkflowOptions) (*ReserveResponse, error) {
	uOptions := client.UpdateWorkflowOptions{}
	if len(options) > 0 {
		uOptions = options[0]
	}
	uOptions.WorkflowID = workflowID
	uOptions.RunID = runID
	uOptions.UpdateName = UpdateReserveName
	uOptions.Args = []interface{}{req}
	if uOptions.WaitForStage == client.WorkflowUpdateStageUnspecified {
		uOptions.WaitForStage = client.WorkflowUpdateStageCompleted
	}

	handle, err := c.client.UpdateWorkflow(ctx, uOptions)
	if err != nil {
		return nil, err
	}

	var resp *ReserveResponse
	err = handle.Get(ctx, &resp)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// HandleUpdateReserve sets up the Reserve update handler, returns an error if it failed
//
// Reserve takes stock out of a TrackInventory workflow. This is a BLOCKING
// update: if there is not enough stock the handler parks on workflow.Await
// until a Restock signal makes the quantity available, and only then
// answers the caller. This is the lease/semaphore pattern
func HandleUpdateReserve(ctx workflow.Context, updateFunc func(ctx workflow.Context, req *ReserveRequest) (*ReserveResponse, error)) error {
	return workflow.SetUpdateHandler(ctx, UpdateReserveName, updateFunc)
}

// HandleUpdateReserveWithValidator sets up the Reserve update handler with a
// validator. The validator runs before the update is admitted to history; if it
// returns a non-nil error the update is rejected and never recorded
//
// Reserve takes stock out of a TrackInventory workflow. This is a BLOCKING
// update: if there is not enough stock the handler parks on workflow.Await
// until a Restock signal makes the quantity available, and only then
// answers the caller. This is the lease/semaphore pattern
func HandleUpdateReserveWithValidator(ctx workflow.Context, updateFunc func(ctx workflow.Context, req *ReserveRequest) (*ReserveResponse, error), validatorFunc func(ctx workflow.Context, req *ReserveRequest) error) error {
	return workflow.SetUpdateHandlerWithOptions(ctx, UpdateReserveName, updateFunc, workflow.UpdateHandlerOptions{
		Validator: validatorFunc,
	})
}