Swift Temporal SDK

https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/
Admin
Build reliable, fault-tolerant distributed workflows using Swift's concurrency features with the...
Tokens:535,955
Snippets:6,933
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Start Child Workflow Usage Examples

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/startchildworkflow%28_%3Aoptions%3Ainput%3A%29

Examples demonstrating how to start a child workflow with default options and with custom task queue options. It also shows how to later retrieve the result from the child workflow handle.

```swift
// Start a child workflow and get a handle
let childHandle = try await Workflow.startChildWorkflow(
    ProcessOrderWorkflow.self,
    input: OrderData(id: "order-456", customerID: "customer-789")
)


// Start with custom task queue
let reportHandle = try await Workflow.startChildWorkflow(
    GenerateReportWorkflow.self,
    options: .init(
        taskQueue: "reports-task-queue"
    ),
    input: ReportRequest(startDate: startDate, endDate: endDate)
)


// Later, get the result
let result = try await childHandle.result()
```

--------------------------------

### Start Worker and Client to Execute Workflow

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/gettingstarted

Create an application that starts a worker with the workflow and activity, and a client to execute the workflow. This example demonstrates setting up the worker and client configurations and running them concurrently.

```swift
import Foundation
import GRPCNIOTransportHTTP2Posix
import Logging
import Temporal


@main
struct GreetingApplication {
    static func main() async throws {
        let logger = Logger(label: "TemporalWorker")


        let namespace = "default"
        let taskQueue = "greeting-queue"


        // Create worker configuration
        let workerConfiguration = TemporalWorker.Configuration(
            namespace: namespace,
            taskQueue: taskQueue,
            instrumentation: .init(serverHostname: "localhost")
        )


        // Create the worker
        let worker = try TemporalWorker(
            configuration: workerConfiguration,
            target: .ipv4(address: "127.0.0.1", port: 7233),
            transportSecurity: .plaintext,
            activityContainers: GreetingActivities(),
            activities: [],
            workflows: [GreetingWorkflow.self],
            logger: logger
        )


        let client = try TemporalClient(
            target: .ipv4(address: "127.0.0.1", port: 7233),
            transportSecurity: .plaintext,
            configuration: .init(
                instrumentation: .init(
                    serverHostname: "localhost"
                )
            ),
            logger: logger
        )


        try await withThrowingTaskGroup { group in
            group.addTask {
                try await worker.run()
            }


            group.addTask {
                try await client.run()
            }


            // Wait for the worker and client to run
            try await Task.sleep(for: .seconds(1))


            print("Executing workflow")
            let greeting = try await client.executeWorkflow(
                type: GreetingWorkflow.self,
                options: .init(id: UUID().uuidString, taskQueue: taskQueue),
                input: "Max"
            )


            print(greeting)


            // Cancel the client and worker
            group.cancelAll()
        }
    }
}

```

--------------------------------

### Create TemporalClient with Configuration

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient

Use the `connect` method with a `TemporalClient.Configuration` to establish a connection to the Temporal cluster. This example demonstrates connecting to a local cluster and starting a workflow.

```swift
let configuration = TemporalClient.Configuration(
    target: .dns(host: "localhost", port: 7233),
    namespace: "default"
)


try await TemporalClient.connect(
    transport: HTTP2ClientTransport.Posix(
        target: configuration.target,
        transportSecurity: .plaintext
    ),
    configuration: configuration
) { client in
    // Use the client
    return try await client.startWorkflow(...)
}
```

--------------------------------

### Swift Usage Example for withConnectedClient

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporaltestkit/temporaltestserver/withconnectedclient%28logger%3A_%3A%29

Demonstrates how to use `withConnectedClient` to obtain a client, start a workflow, query its state, and retrieve its result.

```swift
let testServer = TemporalTestServer.testServer!
try await testServer.withConnectedClient(logger: logger) { client in
    // Execute workflow operations using the connected client
    let handle = try await client.startWorkflow(
        MyWorkflow.self,
        options: WorkflowOptions(id: "test-workflow-\(UUID())")
    )


    // Query workflow state
    let status = try await handle.query(MyWorkflow.statusQuery)


    // Wait for completion and validate results
    let result = try await handle.result()
    XCTAssertEqual(result, expectedValue)
}
```

--------------------------------

### ActivityOptions Usage Examples

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/activityoptions

Examples demonstrating how to configure ActivityOptions for different scenarios, including basic timeouts, heartbeat support, and retry policies.

```APIDOC
## Usage

```swift
// Basic activity with schedule-to-close timeout
let options = ActivityOptions(scheduleToCloseTimeout: .seconds(30))


// Activity with both timeouts and heartbeat
let detailedOptions = ActivityOptions(
    scheduleToCloseTimeout: .minutes(5),
    startToCloseTimeout: .seconds(30),
    heartbeatTimeout: .seconds(10)
)


// Activity with retry policy and custom task queue
let robustOptions = ActivityOptions(
    scheduleToCloseTimeout: .minutes(10),
    heartbeatTimeout: .seconds(15),
    taskQueue: "specialized-workers",
    retryPolicy: RetryPolicy(maximumAttempts: 3)
)
```
```

--------------------------------

### Start Local Temporal Server

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/gettingstarted

Start a local Temporal development server using the Temporal CLI. The server runs at localhost:7233 and hosts a Web UI at http://localhost:8233.

```bash
# Start development server
temporal server start-dev

```

--------------------------------

### Example Usage of withConnectedWorker

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporaltestkit/temporaltestserver/withconnectedworker%28namespace%3Ataskqueue%3Aworkerbuildid%3Amaxheartbeatthrottleinterval%3Ainterceptors%3Aactivities%3Aworkflows%3Alogger%3A_%3A%29

Demonstrates how to use the `withConnectedWorker` helper to set up a worker with specific activities and workflows, then interact with the system under test. The closure provided to `withConnectedWorker` receives the running worker, allowing for operations like starting workflows.

```swift
let testServer = TemporalTestServer.testServer!
let result = try await testServer.withConnectedWorker(
    namespace: "default",
    activities: [MyActivity()],
    workflows: [MyWorkflow.self]
) { worker in
    // Interact with the system under test while the worker is running.
    // For example, start a workflow from a connected client (e.g. via `withConnectedClient()`),
    // then await its result.
}


#expect(result == "...")
```

--------------------------------

### Start Workflow with Options (No Input)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/startworkflow%28type%3Aoptions%3A%29

Use this method to start a workflow that requires no input parameters. It returns a `WorkflowHandle` for managing the workflow instance.

```swift
func startWorkflow<Workflow>(
    type: Workflow.Type = Workflow.self,
    options: WorkflowOptions
) async throws -> WorkflowHandle<Workflow> where Workflow : WorkflowDefinition,
                                                    Workflow.Input == ()

```

--------------------------------

### Start Workflow (Name, Variadic Input)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient

Starts a workflow execution by name with specified input and returns a handle for managing the workflow instance.

```APIDOC
## startWorkflow (Name, Variadic Input)

### Description
Starts a workflow execution and returns a handle for managing the workflow instance.

### Method
`async`

### Signature
`func startWorkflow<each Input>(name: String, options: WorkflowOptions, input: repeat each Input) async throws -> UntypedWorkflowHandle`
```

--------------------------------

### init(name:options:headers:input:callOptions:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/startworkflowinput/init%28name%3Aoptions%3Aheaders%3Ainput%3Acalloptions%3A%29

Creates a new start workflow input with the specified parameters. This initializer is used to configure the details for starting a new workflow execution.

```APIDOC
## init(name:options:headers:input:callOptions:)

### Description
Creates a new start workflow input with the specified parameters.

### Parameters

`name` (String) - Required - The name of the workflow type to start.

`options` (WorkflowOptions) - Required - Configuration options controlling workflow execution behavior.

`headers` ([String : TemporalPayload]) - Required - Headers to include with the workflow start request.

`input` (repeat each Input) - Required - The input arguments to pass to the workflow.

`callOptions` (CallOptions?) - Optional - Optional gRPC call options for customizing the request.
```

--------------------------------

### Start Workflow Swift

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/workflowservice-swift.struct/startworkflow%28name%3Aoptions%3Aheaders%3Ainput%3A%29

Starts a new workflow execution with the specified name and configuration. Use this to initiate a workflow and provide its initial input and options.

```swift
func startWorkflow<each Input>(
    name: String,
    options: WorkflowOptions,
    headers: [String : TemporalPayload] = [:\],
    input: repeat each Input
) async throws -> String where repeat each Input : Sendable
```

--------------------------------

### Start Workflow (Typed, Input)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient

Starts a typed workflow execution with input and returns a handle for managing the workflow instance.

```APIDOC
## startWorkflow<Workflow> (Typed, Input)

### Description
Starts a workflow execution and returns a handle for managing the workflow instance.

### Method
`async`

### Signature
`func startWorkflow<Workflow>(type: Workflow.Type, options: WorkflowOptions, input: Workflow.Input) async throws -> WorkflowHandle<Workflow>`
```

--------------------------------

### Start Temporal Client

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/run%28%29

Starts the underlying gRPC client and keeps it running to handle requests. This method should be called to initiate the client's operation.

```swift
func run() async throws
```

--------------------------------

### Start Workflow Execution

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/startworkflow%28type%3Aoptions%3Ainput%3A%29

Use this method to start a new workflow execution. It requires the workflow type, configuration options, and input data. The returned handle can be used to monitor, query, signal, or wait for the workflow's completion.

```swift
func startWorkflow<Workflow>(
    type: Workflow.Type = Workflow.self,
    options: WorkflowOptions,
    input: Workflow.Input
) async throws -> WorkflowHandle<Workflow> where Workflow : WorkflowDefinition
```

--------------------------------

### Execute Activity with Multiple Inputs

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/executeactivity%28name%3Aoptions%3Ainput%3Aoutputtype%3A%29

Example demonstrating how to execute an activity with multiple input parameters.

```swift
// Execute with multiple inputs
let summary: OrderSummary = try await Workflow.executeActivity(
    name: "GenerateOrderSummary",
    options: .init(startToCloseTimeout: .seconds(30)),
    input: orderID, customerInfo, items,
    outputType: OrderSummary.self
)
```

--------------------------------

### Execute Child Workflow

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/executechildworkflow%28name%3Aoptions%3Ainputs%3Aresulttype%3A%29

Starts a child workflow by name and awaits its result. Use this when you need to run a workflow as a sub-process and get its output.

```swift
static func executeChildWorkflow<each Input, Result>(
    name: String,
    options: ChildWorkflowOptions = .init(),
    inputs: repeat each Input,
    resultType: Result.Type = Result.self
) async throws -> Result where repeat each Input : Sendable, Result : Sendable
```

--------------------------------

### Execute Local Activity with Multiple Inputs

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/executelocalactivity%28name%3Aoptions%3Ainput%3Aoutputtype%3A%29

Example demonstrating how to execute a local activity with multiple input parameters. The inputs are passed as a comma-separated list.

```swift
// Execute with multiple inputs
let summary: OrderSummary = try await Workflow.executeLocalActivity(
    name: "GenerateOrderSummary",
    options: .init(startToCloseTimeout: .seconds(30)),
    input: orderID, customerInfo, items,
    outputType: OrderSummary.self
)
```

--------------------------------

### run()

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/service-implementations

Starts the Temporal client and keeps it running until shutdown is initiated.

```APIDOC
## func run() async throws

### Description
Starts the Temporal client and keeps it running until shutdown is initiated.

### Signature
`func run() async throws`
```

--------------------------------

### init(serverHostname:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/configuration/instrumentation-swift.struct/init%28serverhostname%3A%29

Creates a new client instrumentation configuration with the specified settings.

```APIDOC
## init(serverHostname:)

### Description
Creates a new client instrumentation configuration with the specified settings.

### Signature
```swift
init(serverHostname: String)
```

### Parameters
#### serverHostname
- **serverHostname** (String) - The hostname of the Temporal server for instrumentation purposes.
```

--------------------------------

### init(query:callOptions:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/listschedulesinput/init%28query%3Acalloptions%3A%29

Creates a new list schedules input with the specified parameters.

```APIDOC
## init(query:callOptions:)

### Description
Creates a new list schedules input with the specified parameters.

### Parameters
#### Query Parameters
- **query** (String?) - Optional query string to filter schedules using the schedule query language.
- **callOptions** (CallOptions?) - Optional gRPC call options for customizing the request.
```

--------------------------------

### Execute Operation with Cancellation Shield

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/withcancellationshield%28_%3A%29

Use this method to perform operations that should be shielded from Workflow cancellation. For example, you can use this to execute an activity as part of a cleanup operation when your Workflow is getting cancelled.

```swift
static func withCancellationShield<Result>(_ operation: sending @escaping () async throws -> Result) async throws -> Result where Result : Sendable
```

--------------------------------

### init(configReader:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/configuration/instrumentation-swift.struct/init%28configreader%3A%29

Creates an instrumentation configuration from external configuration data, reading the server hostname from a ConfigReader.

```APIDOC
## init(configReader:)

### Description
Creates an instrumentation configuration from external configuration data.

### Method Signature
```swift
init(configReader: ConfigReader) throws
```

### Parameters
#### `configReader`
- **Type**: `ConfigReader`
- **Description**: The configuration reader containing the required hostname value.

### Discussion
This initializer reads the server hostname from a `ConfigReader`, typically loaded from environment variables or configuration files.

### Required configuration keys
- `client.instrumentation.serverhostname`: The Temporal server hostname for telemetry identification
```

--------------------------------

### Workflow Details Property

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/currentdetails

This static property allows you to get or set details for a workflow. Unlike details set at the start, this value can be updated throughout the life of the workflow and supports Temporal markdown format.

```swift
static var currentDetails: String? { get set }
```

--------------------------------

### WorkflowTaskFailedCause.badStartChildExecutionAttributes Case

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowtaskfailedcause/badstartchildexecutionattributes

This Swift enum case represents a workflow task failure caused by invalid attributes when attempting to start a child execution. No specific setup or imports are required to use this case, as it's part of the SDK's error handling.

```swift
case badStartChildExecutionAttributes
```

--------------------------------

### init(name:kind:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/taskqueue/init%28name%3Akind%3A%29

Initializes a new TaskQueue with a specified name and kind.

```APIDOC
## init(name:kind:)

### Description
Initializes a new TaskQueue with a specified name and kind.

### Parameters
#### Path Parameters
- **name** (String) - Required - The name of the task queue.
- **kind** (TaskQueue.Kind) - Required - The kind of the task queue (e.g., `normal`, `sticky`).

### Request Example
```swift
let taskQueue = TaskQueue(name: "my-task-queue", kind: .normal)
```

### Response
#### Success Response (200)
- **TaskQueue** (TaskQueue) - The newly created TaskQueue instance.
```

--------------------------------

### init()

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/binaryprotobufpayloadconverter/init%28%29

Initializes a new instance of the BinaryProtobufPayloadConverter.

```APIDOC
## init()

### Description
Initializes a new instance of the BinaryProtobufPayloadConverter.

### Method
Initializer

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Response Example
N/A
```

--------------------------------

### executionTime

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowexecution/executiontime

The timestamp when the workflow execution should start or did start. This may differ from `startTime` for scheduled workflows that have a delayed start time.

```APIDOC
## executionTime

### Description
The timestamp when the workflow execution should start or did start. This may differ from `startTime` for scheduled workflows that have a delayed start time.

### Signature
```swift
var executionTime: Date?
```
```

--------------------------------

### Execute Local Activity with Input

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/executelocalactivity%28_%3Aoptions%3Ainput%3A%29-40ddu

Example of executing a local activity with basic input. Ensure the activity type and options are correctly defined.

```swift
// Execute a local activity with input
let result = try await Workflow.executeLocalActivity(
    ProcessOrderActivity.self,
    options: .init(startToCloseTimeout: .seconds(30)),
    input: OrderRequest(id: "order-123", items: items)
)
```

--------------------------------

### ScheduleRange start Property Declaration

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/schedulerange/start

Declares the 'start' property for a ScheduleRange. This property is an Integer and represents the inclusive starting value of the range.

```swift
let start: Int
```

--------------------------------

### Instance Property: executionTime

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowexecution/executiontime

The timestamp when the workflow execution should start or did start. This may differ from `startTime` for scheduled workflows that have a delayed start time.

```swift
var executionTime: Date?
```

--------------------------------

### Example Application Output

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/gettingstarted

This is the expected output when running the GreetingApplication. It shows the workflow execution message and the greeting returned by the workflow.

```text
Executing workflow
Hello, Max!

```

--------------------------------

### TemporalClient.Configuration.init

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/configuration/init%28instrumentation%3Anamespace%3Aidentity%3Adataconverter%3Ainterceptors%3Aapikey%3A%29

Creates a new client configuration with the specified settings. All parameters have sensible defaults except for the instrumentation configuration, which must be provided.

```APIDOC
## init(instrumentation:namespace:identity:dataConverter:interceptors:apiKey:)

### Description
Creates a new client configuration with the specified settings.

### Parameters
#### `instrumentation` (TemporalClient.Configuration.Instrumentation) - Required - Configuration that controls tracing and observability features.
#### `namespace` (String) - Optional - Defaults to "default". The Temporal namespace that scopes workflow and activity executions.
#### `identity` (String?) - Optional - A human-readable identifier for this client process. If `nil`, an identity is generated from the SDK name and version.
#### `dataConverter` (DataConverter) - Optional - Defaults to `DataConverter.default`. The converter that handles serialization of workflow data.
#### `interceptors` ([any ClientInterceptor]) - Optional - Defaults to `[TemporalClientTracingInterceptor()]`. Request processing interceptors applied in the specified order.
#### `apiKey` (String?) - Optional - The API key to use for authenticating with a Temporal Cloud instance. Defaults to none.

### Discussion
This initializer creates a configuration with explicit parameter values. All parameters have sensible defaults except for the instrumentation configuration, which must be provided since it contains server-specific connection details.

By default, the `TemporalClientTracingInterceptor` is included in the interceptors list to provide distributed tracing capabilities. To disable tracing, pass an empty array or a custom list of interceptors that doesn’t include the tracing interceptor.

If no identity is provided, one is automatically generated using the format `swift-temporal-<version>` where `<version>` is the current SDK version. This ensures each client instance has a unique identifier for logging and monitoring purposes.
```

--------------------------------

### Sequence starts(with:by:) Method Signature

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/searchattributecollection/starts%28with%3Aby%3A%29

This is the signature for the `starts(with:by:)` method inherited from `Sequence`. It allows checking if a sequence starts with a given prefix, using a custom closure to determine element equivalence.

```swift
func starts<PossiblePrefix>(
    with possiblePrefix: PossiblePrefix,
    by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool
) rethrows -> Bool where PossiblePrefix : Sequence
```

--------------------------------

### ScheduleRange.start

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/schedulerange/start

The 'start' property represents the inclusive starting value of the range. It is an integer.

```APIDOC
## start

### Description
The inclusive starting value of the range.

### Instance Property
```swift
let start: Int
```
```

--------------------------------

### Eager Workflow Start Capability

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/namespaceinfo/capabilities-swift.struct

Indicates whether eager workflow start is supported within the namespace.

```swift
var eagerWorkflowStart: Bool
```

--------------------------------

### init()

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/binarypayloadconverter/init%28%29

Initializes a new binary payload converter.

```APIDOC
## init()

### Description
Initializes a new binary payload converter.

### Method
init()

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

--------------------------------

### WorkflowUpdate Macro Usage Example

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowupdate%28name%3Adescription%3A%29

Example demonstrating the usage of the @WorkflowUpdate macro within a workflow class.

```APIDOC
## Usage

```swift
@Workflow
final class GreetingWorkflow {
    var shouldGreet: Bool
    var name: String


    func run(context: WorkflowContext, input: String) async throws -> String {
        self.name = name
        try await Workflow.condition { self.shouldGreet }
        return try await executeActivity(
            GreetingActivity.self,
            input: name
        )
    }


    @WorkflowUpdate
    func greet() async throws -> String {
        self.shouldGreet = true
        return self.name
    }
}
```
```

--------------------------------

### Creating a Temporal Client

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient

Demonstrates how to create a Temporal client using the `connect` method with custom configuration and transport.

```APIDOC
## Creating a client
Use the `connect(transport:configuration:logger:_:)` method for a lifetime-scoped client:
```swift
let configuration = TemporalClient.Configuration(
    target: .dns(host: "localhost", port: 7233),
    namespace: "default"
)


try await TemporalClient.connect(
    transport: HTTP2ClientTransport.Posix(
        target: configuration.target,
        transportSecurity: .plaintext
    ),
    configuration: configuration
) { client in
    // Use the client
    return try await client.startWorkflow(...)
}
```
```

--------------------------------

### WorkflowTaskFailedCause: Start Timer Duplicate ID

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowtaskfailedcause

Indicates that a workflow task failed because of a duplicate ID when starting a timer.

```swift
`case startTimerDuplicateID`
```

--------------------------------

### WorkflowAlreadyStartedError Initializer

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowalreadystartederror/init%28cause%3Astacktrace%3Aworkflowid%3Arunid%3Aworkflowname%3A%29

Initializes a new workflow already started error. Use this when a workflow with the same ID has already been started.

```swift
init(
    cause: (any Error)? = nil,
    stackTrace: String = "",
    workflowID: String,
    runID: String?,
    workflowName: String
)
```

--------------------------------

### init(taskQueue:taskTimeout:runTimeout:retryPolicy:memo:searchAttributes:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/continueasnewoptions/init%28taskqueue%3Atasktimeout%3Aruntimeout%3Aretrypolicy%3Amemo%3Asearchattributes%3A%29

Creates continue-as-new options with the specified configuration parameters. All parameters are optional and will inherit values from the current workflow execution if not provided.

```APIDOC
## init(taskQueue:taskTimeout:runTimeout:retryPolicy:memo:searchAttributes:)

### Description
Creates continue-as-new options with the specified configuration parameters.

### Parameters

- **taskQueue** (String?): The task queue for the new execution. If `nil`, uses current workflow’s task queue.
- **taskTimeout** (Duration?): Maximum time for processing workflow tasks. If `nil`, uses current workflow’s task timeout.
- **runTimeout** (Duration?): Maximum time for a single workflow run. If `nil`, uses current workflow’s run timeout.
- **retryPolicy** (RetryPolicy?): Retry policy for failed executions. If `nil`, uses current workflow’s retry policy.
- **memo** ([String : any Sendable]?): Metadata for the new execution. If `nil`, uses current workflow’s memo.
- **searchAttributes** (SearchAttributeCollection?): Indexed attributes for workflow search. If `nil`, uses current workflow’s search attributes.

### Discussion
All parameters are optional, allowing you to configure only the aspects that need to change from the current workflow execution. Unspecified parameters will inherit their values from the current workflow, ensuring continuity of operational settings.
```

--------------------------------

### Activity Task Started Case

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/historyevent/attributes-swift.enum/activitytaskstarted%28_%3A%29

Represents the event where an activity task has started. This case is part of the HistoryEvent.Attributes enum.

```swift
case activityTaskStarted(HistoryEvent.Attributes.ActivityTaskStarted)
```

--------------------------------

### Execute Local Activity with Retry Policy

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/executelocalactivity%28_%3Aoptions%3Ainput%3A%29-40ddu

Example demonstrating how to execute a local activity with a configured retry policy. This is useful for transient failures.

```swift
// Execute with retry policy
let emailResult = try await Workflow.executeLocalActivity(
    SendEmailActivity.self,
    options: .init(
        startToCloseTimeout: .seconds(60),
        retryPolicy: .init(
            maximumAttempts: 3,
            initialInterval: .seconds(1)
        )
    ),
    input: EmailData(to: "user@example.com", subject: "Order Confirmation")
)
```

--------------------------------

### init(details:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/heartbeatinput/init%28details%3A%29

Creates heartbeat input with the specified progress details.

```APIDOC
## init(details:)

### Description
Creates heartbeat input with the specified progress details.

### Parameters
#### details
- **details** (repeat each Detail) - Required - The progress details to include in the heartbeat.
```

--------------------------------

### Accessing Activity Start Time in Swift

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/activityexecutioncontext/info-swift.struct/startedtime

Retrieve the timestamp when the activity execution started. This property is of type Date.

```swift
var startedTime: Date
```

--------------------------------

### WorkflowTaskFailedCause: Bad Start Timer Attributes

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowtaskfailedcause

Indicates that a workflow task failed due to invalid attributes for starting a timer.

```swift
`case badStartTimerAttributes`
```

--------------------------------

### startWorkflow(type:options:headers:input:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/workflowservice-swift.struct/startworkflow%28type%3Aoptions%3Aheaders%3Ainput%3A%29

Starts a new strongly-typed workflow execution using a workflow definition. This method provides type-safe workflow starting using a `WorkflowDefinition` that encapsulates the workflow name and input type, ensuring compile-time type safety and reducing runtime errors.

```APIDOC
## startWorkflow(type:options:headers:input:)

### Description
Starts a new strongly-typed workflow execution using a workflow definition.

### Method Signature
```swift
func startWorkflow<Workflow>(type: Workflow.Type = Workflow.self, options: WorkflowOptions, headers: [String : TemporalPayload] = [:], input: Workflow.Input) async throws -> String where Workflow : WorkflowDefinition
```

### Parameters
#### `type`
- **Workflow.Type** - The `WorkflowDefinition` type that defines the workflow contract and input type.

#### `options`
- **WorkflowOptions** - Configuration options controlling workflow execution behavior, timeouts, and policies.

#### `headers`
- **[String : TemporalPayload]** - Custom headers for tracing, authentication, or workflow context.

#### `input`
- **Workflow.Input** - The input parameter matching the workflow definition’s `Input` type.

### Return Value
- **String** - The unique run ID of the started workflow execution for tracking and operations.

### Discussion
This convenience method provides type-safe workflow starting using a `WorkflowDefinition` that encapsulates the workflow name and input type. This approach ensures compile-time type safety and reduces the possibility of runtime type conversion errors while providing automatic workflow name resolution.

### Throws
- `WorkflowAlreadyStartedError` if a workflow with the same ID is already running (depending on ID reuse policy).
- Other errors for startup failures.
```

--------------------------------

### init()

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/binarynilpayloadconverter/init%28%29

Creates a new binary nil payload converter.

```APIDOC
## init()

### Description
Creates a new binary nil payload converter.

### Method
initializer

### Endpoint
N/A

### Parameters
None

### Request Example
```swift
init()
```

### Response
N/A
```

--------------------------------

### Start Workflow (Typed, No Input)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient

Starts a typed workflow execution with no input and returns a handle for managing the workflow instance.

```APIDOC
## startWorkflow<Workflow> (Typed, No Input)

### Description
Starts a workflow execution with no input and returns a handle for managing the workflow instance.

### Method
`async`

### Signature
`func startWorkflow<Workflow>(type: Workflow.Type, options: WorkflowOptions) async throws -> WorkflowHandle<Workflow>`
```

--------------------------------

### Instance Methods

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporaltestkit/temporaltimeskippingtestservertrait/trait-implementations

Prepares the test server for a given test scenario.

```APIDOC
## prepare(for: Test)

### Description
Asynchronously prepares the test server for a given `Test` instance. This method can throw errors.

### Signature
`func prepare(for: Test) async throws`

### Parameters
#### Path Parameters
- **test** (Test) - Required - The test instance to prepare for.
```

--------------------------------

### Start Workflow (Name, No Input)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient

Starts a workflow execution by name with no input and returns a handle for managing the workflow instance.

```APIDOC
## startWorkflow (Name, No Input)

### Description
Starts a workflow execution with no input and returns a handle for managing the workflow instance.

### Method
`async`

### Signature
`func startWorkflow(name: String, options: WorkflowOptions) async throws -> UntypedWorkflowHandle`
```

--------------------------------

### init(workflowName:options:headers:input:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/scheduleaction/actionstartworkflow/init%28workflowname%3Aoptions%3Aheaders%3Ainput%3A%29

Creates a schedule action for starting workflow executions with input data.

```APIDOC
## init(workflowName:options:headers:input:)

### Description
Creates a schedule action for starting workflow executions with input data.

### Parameters

#### `workflowName`

The name of the workflow associated with this schedule.

#### `options`

Workflow execution options including timeouts and retry policies.

#### `headers`

Custom headers to include with workflow execution.

#### `input`

The input data to pass to the workflow.
```

--------------------------------

### startChildWorkflow(_:options:input:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/startchildworkflow%28_%3Aoptions%3Ainput%3A%29

Starts a child workflow with the specified type, options, and input.

```APIDOC
## startChildWorkflow(_:options:input:)

### Description
Starts a child workflow.

### Method Signature
```swift
static func startChildWorkflow<ChildWorkflow>(
    _ workflowType: ChildWorkflow.Type = ChildWorkflow.self,
    options: ChildWorkflowOptions = .init(),
    input: ChildWorkflow.Input
) async throws -> ChildWorkflowHandle<ChildWorkflow> where ChildWorkflow : WorkflowDefinition
```

### Parameters

- `workflowType` (ChildWorkflow.Type) - The workflow’s type.
- `options` (ChildWorkflowOptions) - The child workflow options.
- `input` (ChildWorkflow.Input) - The input to the workflow.

### Return Value
A handle to the child workflow.

### Usage
```swift
// Start a child workflow and get a handle
let childHandle = try await Workflow.startChildWorkflow(
    ProcessOrderWorkflow.self,
    input: OrderData(id: "order-456", customerID: "customer-789")
)


// Start with custom task queue
let reportHandle = try await Workflow.startChildWorkflow(
    GenerateReportWorkflow.self,
    options: .init(
        taskQueue: "reports-task-queue"
    ),
    input: ReportRequest(startDate: startDate, endDate: endDate)
)


// Later, get the result
let result = try await childHandle.result()
```
```

--------------------------------

### init(id:callOptions:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/describescheduleinput/init%28id%3Acalloptions%3A%29

Creates a new describe schedule input with the specified parameters. This initializer is used to prepare the input for describing a specific schedule.

```APIDOC
## init(id:callOptions:)

### Description
Creates a new describe schedule input with the specified parameters.

### Parameters

#### Parameters

- **id** (String) - Required - The unique identifier of the schedule to describe.
- **callOptions** (CallOptions?) - Optional - Optional gRPC call options for customizing the request.
```

--------------------------------

### Start Workflow with No Input

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/startworkflow%28name%3Aoptions%3A%29

Use this method to start a workflow that does not accept any input. It requires the workflow name and configuration options.

```swift
func startWorkflow(
    name: String,
    options: WorkflowOptions
) async throws -> UntypedWorkflowHandle
```

--------------------------------

### HistoryEvent.Attributes.timerStarted(_:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/historyevent/attributes-swift.enum/timerstarted%28_%3A%29

Represents a timer start event. This case is part of the HistoryEvent.Attributes enum and holds the specific attributes for a timer that has been started.

```APIDOC
## HistoryEvent.Attributes.timerStarted(_:)

### Description
This case represents the event where a timer has been started. It is part of the `HistoryEvent.Attributes` enum, which encapsulates various types of history events.

### Enum Case
```swift
case timerStarted(HistoryEvent.Attributes.TimerStarted)
```

### Parameters
- **HistoryEvent.Attributes.TimerStarted**: The associated value containing the specific details of the timer start event.
```

--------------------------------

### init(details:callOptions:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/asyncactivityheartbeatoptions/init%28details%3Acalloptions%3A%29

Initializes AsyncActivityHeartbeatOptions with heartbeat details and optional gRPC call options.

```APIDOC
## init(details:callOptions:)

### Description
Create options for heartbeats in async activities.

### Parameters
#### details
- **details** ([any Sendable]) - Required - The details for the heartbeat.

#### callOptions
- **callOptions** (CallOptions?) - Optional - Optional gRPC call options for customizing the request.
```

--------------------------------

### init(attempt:startTime:workflowName:workflowID:workflowType:runID:taskQueue:namespace:headers:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowinfo/init%28attempt%3Astarttime%3Aworkflowname%3Aworkflowid%3Aworkflowtype%3Arunid%3Ataskqueue%3Anamespace%3Aheaders%3A%29

Creates a new workflow information instance with detailed workflow parameters.

```APIDOC
## init(attempt:startTime:workflowName:workflowID:workflowType:runID:taskQueue:namespace:headers:)

### Description
Creates a new workflow information instance.

### Parameters
#### Parameters
- **attempt** (Int) - The current attempt number.
- **startTime** (Date) - When the workflow was started.
- **workflowName** (String) - The workflow’s name.
- **workflowID** (String) - The unique workflow identifier.
- **workflowType** (String) - The workflow type name.
- **runID** (String) - The current run identifier.
- **taskQueue** (String) - The task queue name.
- **namespace** (String) - The Temporal namespace.
- **headers** ([String : TemporalPayload]) - Associated headers.
```

--------------------------------

### startWorkflow(input:next:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/clientoutboundinterceptor/startworkflow%28input%3Anext%3A%29

Intercepts workflow start operations. This method allows custom logic to be applied before a workflow is started.

```APIDOC
## startWorkflow(input:next:)

### Description
Intercepts workflow start operations. This method allows custom logic to be applied before a workflow is started.

### Method Signature
```swift
func startWorkflow<each Input>(
    input: StartWorkflowInput<repeat each Input>,
    next: (StartWorkflowInput<repeat each Input>) async throws -> UntypedWorkflowHandle
) async throws -> UntypedWorkflowHandle where repeat each Input : Sendable
```

### Parameters
#### `input`
- **Type**: `StartWorkflowInput<repeat each Input>`
- **Description**: The workflow start input containing workflow type, ID, options, and parameters.

#### `next`
- **Type**: `(StartWorkflowInput<repeat each Input>) async throws -> UntypedWorkflowHandle`
- **Description**: A closure that forwards the operation to the next interceptor.

### Return Value
- **Type**: `UntypedWorkflowHandle`
- **Description**: An untyped workflow handle for the started workflow execution.
```

--------------------------------

### StartWorkflowInput Headers

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/startworkflowinput/headers

Headers to include with the workflow start request. This property allows you to attach custom metadata to your workflow start requests.

```APIDOC
## Instance Property

# headers

Headers to include with the workflow start request.

```swift
var headers: [String : TemporalPayload]
```

### Description

This property is a dictionary where keys are strings representing header names and values are `TemporalPayload` objects, allowing for structured data to be passed as headers.
```

--------------------------------

### init(workflowName:options:headers:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/scheduleaction/actionstartworkflow/init%28workflowname%3Aoptions%3Aheaders%3A%29

Creates a schedule action for starting workflow executions with input data.

```APIDOC
## init(workflowName:options:headers:)

### Description
Creates a schedule action for starting workflow executions with input data.

### Parameters
#### Path Parameters
* **workflowName** (String) - Required - The name of the workflow associated with this schedule.
* **options** (WorkflowOptions) - Required - Workflow execution options including timeouts and retry policies.
* **headers** ([String : TemporalPayload]) - Optional - Custom headers to include with workflow execution.
```

--------------------------------

### init(query:limit:callOptions:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/listworkflowsinput/init%28query%3Alimit%3Acalloptions%3A%29

Creates a new list workflows input with the specified parameters.

```APIDOC
## init(query:limit:callOptions:)

### Description
Creates a new list workflows input with the specified parameters.

### Parameters
#### Query Parameters
- **query** (String) - Required - The query string to filter workflow executions using the visibility query language.
- **limit** (Int?) - Optional - Optional maximum number of workflow executions to return.
- **callOptions** (CallOptions?) - Optional - Optional gRPC call options for customizing the request.
```

--------------------------------

### ScheduleAction Case for Starting Workflow

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/scheduleaction/startworkflow%28_%3A%29

This case is used to define a schedule action that starts a workflow execution. It is part of the `ScheduleAction` enum.

```swift
case startWorkflow(ScheduleAction<Input>.ActionStartWorkflow)
```

--------------------------------

### init(callOptions:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/asyncactivitycompleteoptions/init%28calloptions%3A%29

Initializes AsyncActivityCompletionOptions with optional gRPC call options.

```APIDOC
## init(callOptions:)

### Description
Create options for completing an async activity.

### Method Signature
```swift
init(callOptions: CallOptions? = nil)
```

### Parameters
#### callOptions
- **callOptions** (CallOptions?) - Optional gRPC call options for customizing the request.
```

--------------------------------

### WorkflowTaskFailedCause: Bad Start Child Execution Attributes

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflowtaskfailedcause

Indicates that a workflow task failed due to invalid attributes for starting a child execution.

```swift
`case badStartChildExecutionAttributes`
```

--------------------------------

### Start Child Workflow Signature

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/startchildworkflow%28_%3Aoptions%3Ainput%3A%29

This is the static method signature for starting a child workflow. It allows specifying the workflow type, options, and input.

```swift
static func startChildWorkflow<ChildWorkflow>(
    _ workflowType: ChildWorkflow.Type = ChildWorkflow.self,
    options: ChildWorkflowOptions = .init(),
    input: ChildWorkflow.Input
) async throws -> ChildWorkflowHandle<ChildWorkflow> where ChildWorkflow : WorkflowDefinition
```

--------------------------------

### Continue with multiple parameters

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/makecontinueasnewerror%28options%3Ainput%3A%29

This example shows how to pass multiple distinct parameters as input when continuing a workflow.

```swift
// Continue with multiple parameters
let continueError = try await Workflow.makeContinueAsNewError(
    options: .init(),
    input: newUserID, updatedConfig, processedCount
)
throw continueError
```

--------------------------------

### init(seriesName:buildID:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/deployment/init%28seriesname%3Abuildid%3A%29

Initializes a new instance of the Temporal deployment with a specified series name and build ID.

```APIDOC
## init(seriesName:buildID:)

### Description
Initializes a new instance of the Temporal deployment with a specified series name and build ID.

### Parameters
#### Path Parameters
- **seriesName** (String) - Required - The name of the series for the deployment.
- **buildID** (String) - Required - The unique identifier for the build.

### Code
```swift
init(
    seriesName: String,
    buildID: String
)
```
```

--------------------------------

### LocalActivityOptions Swift Initialization

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/localactivityoptions

Demonstrates initializing LocalActivityOptions with different timeout and retry configurations. Ensure at least one timeout is set to avoid activity execution failure.

```swift
let options = LocalActivityOptions(scheduleToCloseTimeout: .seconds(30))
```

```swift
let detailedOptions = LocalActivityOptions(
    scheduleToCloseTimeout: .minutes(5),
    startToCloseTimeout: .seconds(30)
)
```

```swift
let robustOptions = LocalActivityOptions(
    scheduleToCloseTimeout: .minutes(10),
    retryPolicy: RetryPolicy(maximumAttempts: 3)
)
```

--------------------------------

### parentPinnedWorkerDeploymentVersion

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/historyevent/attributes-swift.enum/workflowexecutionstarted/parentpinnedworkerdeploymentversion

When present, it means this is a child workflow of a parent that is Pinned to this Worker Deployment Version. In this case, the child workflow will start as Pinned to this Version instead of starting on the Current Version of its Task Queue. This is set only if the child workflow is starting on a Task Queue belonging to the same Worker Deployment Version.

```APIDOC
## Instance Property

### parentPinnedWorkerDeploymentVersion

When present, it means this is a child workflow of a parent that is Pinned to this Worker Deployment Version.

```swift
var parentPinnedWorkerDeploymentVersion: String?
```

## Discussion

In this case, child workflow will start as Pinned to this Version instead of starting on the Current Version of its Task Queue. This is set only if the child workflow is starting on a Task Queue belonging to the same Worker Deployment Version.
```

--------------------------------

### init()

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/jsonprotobufpayloadconverter/init%28%29

Initializes a new instance of JSONProtobufPayloadConverter.

```APIDOC
## init()

### Description
Initializes a new instance of the JSONProtobufPayloadConverter.

### Method
`init()`

### Parameters
This initializer does not take any parameters.

### Request Example
```swift
let converter = JSONProtobufPayloadConverter()
```

### Response
This initializer does not return a value.
```

--------------------------------

### Using withTestServer for Integration Tests

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporaltestkit/temporaltestserver/withtestserver%28_%3A%29

Demonstrates how to use withTestServer to set up a test server and client for performing integration tests. This includes starting a workflow and retrieving its result.

```swift
try await TemporalTestServer.withTestServer { testServer in
    try await testServer.withConnectedClient(logger: logger) { client in
        // Perform integration tests with the client
        let handle = try await client.startWorkflow(
            MyWorkflow.self,
            options: WorkflowOptions(id: "integration-test")
        )
        let result = try await handle.result()
        // Validate workflow execution results
    }
}
```

--------------------------------

### Activity Test Environment Setup

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporaltestkit/withactivitytestenvironment%28info%3Acancellationreason%3Alogger%3A_%3A%29

Use this function to create a test environment for Temporal Activities that depend on ActivityExecutionContext. It allows mocking of activity info, cancellation reasons, and logging.

```swift
func withActivityTestEnvironment<Return>(
    info: ActivityExecutionContext.Info,
    cancellationReason: ActivityCancellationReason? = nil,
    logger: Logger = Logger(label: "no-log-handler", factory: { _ in SwiftLogNoOpLogHandler() }),
    _ body: () async throws -> Return
) async rethrows -> Return
```

--------------------------------

### init(workflowType:options:headers:input:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/scheduleaction/actionstartworkflow/init%28workflowtype%3Aoptions%3Aheaders%3Ainput%3A%29

Creates a schedule action for starting workflow executions with input data.

```APIDOC
## init(workflowType:options:headers:input:)

### Description
Creates a schedule action for starting workflow executions with input data.

### Parameters
#### Path Parameters
* **workflowType** (Workflow.Type) - Optional - The type of workflow to execute (typically inferred from context).
* **options** (WorkflowOptions) - Required - Workflow execution options including timeouts and retry policies.
* **headers** (Dictionary<String, TemporalPayload>) - Optional - Custom headers to include with workflow execution.
* **input** (Workflow.Input) - Required - The input data to pass to the workflow.
```

--------------------------------

### Timer Started Event Type Case

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/eventtype/timerstarted

This Swift code defines the `timerStarted` case within the `EventType` enum. Use this case to identify when a timer has been started.

```swift
case timerStarted
```

--------------------------------

### Install TemporalClientTracingInterceptor

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclienttracinginterceptor

Install the interceptor on your TemporalClient configuration to enable automatic tracing. For optimal diagnostic coverage, position this interceptor as the final entry in your interceptor chain.

```swift
let client = TemporalClient(
    configuration: .init(
        interceptors: [TemporalClientTracingInterceptor()]
    )
)
```

--------------------------------

### init(id:runID:queryName:rejectionCondition:headers:input:callOptions:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/queryworkflowinput/init%28id%3Arunid%3Aqueryname%3Arejectioncondition%3Aheaders%3Ainput%3Acalloptions%3A%29

Creates a new query workflow input with the specified parameters.

```APIDOC
## init(id:runID:queryName:rejectionCondition:headers:input:callOptions:)

### Description
Creates a new query workflow input with the specified parameters.

### Parameters
#### Path Parameters
* **id** (String) - Required - The unique identifier of the workflow to query.
* **runID** (String?) - Optional - The specific run ID of the workflow execution to query.
* **queryName** (String) - Required - The name of the query to execute on the workflow.
* **rejectionCondition** (QueryRejectionCondition?) - Optional - Optional condition under which the query should be rejected.
* **headers** ([String : TemporalPayload]) - Required - Headers to include with the query request.
* **input** (repeat each Input) - Required - The input arguments to pass to the query handler.
* **callOptions** (CallOptions?) - Optional - Optional gRPC call options for customizing the request.
```

--------------------------------

### startWorkflow(type:options:input:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/startworkflow%28type%3Aoptions%3Ainput%3A%29

Starts a workflow execution and returns a handle for managing the workflow instance.

```APIDOC
## startWorkflow(type:options:input:)

### Description
Starts a workflow execution and returns a handle for managing the workflow instance.

### Method Signature
```swift
func startWorkflow<Workflow>(
    type: Workflow.Type = Workflow.self,
    options: WorkflowOptions,
    input: Workflow.Input
) async throws -> WorkflowHandle<Workflow> where Workflow : WorkflowDefinition
```

### Parameters

*   **type** (`Workflow.Type`) - The workflow type that defines the business logic to execute.
*   **options** (`WorkflowOptions`) - Configuration options including workflow ID, task queue, and execution policies.
*   **input** (`Workflow.Input`) - The input data to pass to the workflow.

### Return Value
A `WorkflowHandle` for monitoring and controlling the started workflow.

### Discussion
This method initiates a new workflow execution on the Temporal cluster and immediately returns a handle that can be used to monitor, query, signal, or wait for the workflow’s completion. The returned handle provides access to the workflow’s result through `result(followRuns:callOptions:)` and supports various control operations like signaling and querying. The handle’s `runID` is not set by this method; use `workflowHandle(type:id:runID:firstExecutionRunID:)` if you need to specify a particular run ID.

### Run ID Behavior
The run ID generated by the Temporal server is available in both `resultRunID` and `firstExecutionRunID` properties of the returned handle. This run ID uniquely identifies this specific execution attempt of the workflow.
```

--------------------------------

### resultRunID

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/untypedworkflowhandle/resultrunid

The run ID used as the starting point for result retrieval operations. This run ID determines where to begin following workflow execution chains when retrieving results. It handles continue-as-new workflows by following the chain from this starting point. This field is set when starting a workflow but remains nil when obtaining a handle to an existing workflow.

```APIDOC
## Instance Property

### resultRunID

The run ID used as the starting point for result retrieval operations.

```swift
let resultRunID: String?
```

### Discussion

This run ID determines where to begin following workflow execution chains when retrieving results. It handles continue-as-new workflows by following the chain from this starting point. This field is set when starting a workflow but remains `nil` when obtaining a handle to an existing workflow.
```

--------------------------------

### TemporalClient.Configuration Initializer

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/temporalclient/configuration/init%28instrumentation%3Anamespace%3Aidentity%3Adataconverter%3Ainterceptors%3Aapikey%3A%29

Creates a new client configuration with the specified settings. All parameters have sensible defaults except for the instrumentation configuration, which must be provided.

```swift
init(
    instrumentation: TemporalClient.Configuration.Instrumentation,
    namespace: String = "default",
    identity: String? = nil,
    dataConverter: DataConverter = DataConverter.default,
    interceptors: [any ClientInterceptor] = [TemporalClientTracingInterceptor()],
    apiKey: String? = nil
)
```

--------------------------------

### Start Child Workflow by Name

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/workflow/startchildworkflow%28name%3Aoptions%3Ainputs%3A%29

Use this method to start a child workflow by its type name. Provide options and inputs as needed. Returns a handle to the child workflow.

```swift
static func startChildWorkflow<each Input>(
    name: String,
    options: ChildWorkflowOptions = .init(),
    inputs: repeat each Input
) async throws -> UntypedChildWorkflowHandle where repeat each Input : Sendable
```

--------------------------------

### init(details:callOptions:)

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/asyncactivityreportcancellationoptions/init%28details%3Acalloptions%3A%29

Initializes AsyncActivityReportCancellationOptions with cancellation details and optional gRPC call options.

```APIDOC
## init(details:callOptions:)

### Description
Create options for reporting cancellation of async activities.

### Parameters
#### Parameters
- **details** ([any Sendable]) - The details for the cancellation.
- **callOptions** (CallOptions?) - Optional gRPC call options for customizing the request.
```

--------------------------------

### Declare resultRunID Property

Source: https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal/untypedworkflowhandle/resultrunid

This property is an optional String that holds the run ID to start result retrieval from. It is set when a workflow is started but is nil for existing workflow handles.

```swift
let resultRunID: String?
```
Tokens:
Raw