@temporal-contract/contract

---

@temporal-contract/contract

Type Aliases

ActivityDefinition

type ActivityDefinition<TInput, TOutput> = object;

Defined in: types.ts:13

Definition of an activity

Type Parameters

Type Parameter	Default type
TInput extends AnySchema	AnySchema
TOutput extends AnySchema	AnySchema

Properties

Property	Modifier	Type	Defined in
input	readonly	TInput	types.ts:17
output	readonly	TOutput	types.ts:18

---

AnySchema

type AnySchema = StandardSchemaV1;

Defined in: types.ts:8

Base types for validation schemas Any schema that implements the Standard Schema specification This includes Zod, Valibot, ArkType, and other compatible libraries

---

ContractDefinition

type ContractDefinition<TWorkflows, TActivities> = object;

Defined in: types.ts:70

Contract definition containing workflows and optional global activities

Type Parameters

Type Parameter	Default type
TWorkflows extends Record<string, WorkflowDefinition>	Record<string, WorkflowDefinition>
TActivities extends Record<string, ActivityDefinition>	Record<string, ActivityDefinition>

Properties

Property	Modifier	Type	Defined in
activities?	readonly	TActivities	types.ts:76
taskQueue	readonly	string	types.ts:74
workflows	readonly	TWorkflows	types.ts:75

---

InferActivityNames

type InferActivityNames<TContract> = TContract["activities"] extends Record<string, ActivityDefinition> ? keyof TContract["activities"] & string : never;

Defined in: types.ts:104

Extract activity names from a contract (global activities) as a union type

Type Parameters

Type Parameter
TContract extends ContractDefinition

Example

type MyActivityNames = InferActivityNames<typeof myContract>;
// "log" | "sendEmail"

---

InferContractWorkflows

type InferContractWorkflows<TContract> = TContract["workflows"];

Defined in: types.ts:117

Extract all workflows from a contract with their definitions

Type Parameters

Type Parameter
TContract extends ContractDefinition

Example

type MyWorkflows = InferContractWorkflows<typeof myContract>;

---

InferWorkflowNames

type InferWorkflowNames<TContract> = keyof TContract["workflows"] & string;

Defined in: types.ts:92

Extract workflow names from a contract as a union type

Type Parameters

Type Parameter
TContract extends ContractDefinition

Example

type MyWorkflowNames = InferWorkflowNames<typeof myContract>;
// "processOrder" | "sendNotification"

---

QueryDefinition

type QueryDefinition<TInput, TOutput> = object;

Defined in: types.ts:31

Definition of a query

Type Parameters

Type Parameter	Default type
TInput extends AnySchema	AnySchema
TOutput extends AnySchema	AnySchema

Properties

Property	Modifier	Type	Defined in
input	readonly	TInput	types.ts:35
output	readonly	TOutput	types.ts:36

---

SignalDefinition

type SignalDefinition<TInput> = object;

Defined in: types.ts:24

Definition of a signal

Type Parameters

Type Parameter	Default type
TInput extends AnySchema	AnySchema

Properties

Property	Modifier	Type	Defined in
input	readonly	TInput	types.ts:25

---

UpdateDefinition

type UpdateDefinition<TInput, TOutput> = object;

Defined in: types.ts:42

Definition of an update

Type Parameters

Type Parameter	Default type
TInput extends AnySchema	AnySchema
TOutput extends AnySchema	AnySchema

Properties

Property	Modifier	Type	Defined in
input	readonly	TInput	types.ts:46
output	readonly	TOutput	types.ts:47

---

WorkflowDefinition

type WorkflowDefinition<TActivities, TSignals, TQueries, TUpdates> = object;

Defined in: types.ts:53

Definition of a workflow

Type Parameters

Type Parameter	Default type
TActivities extends Record<string, ActivityDefinition>	Record<string, ActivityDefinition>
TSignals extends Record<string, SignalDefinition>	Record<string, SignalDefinition>
TQueries extends Record<string, QueryDefinition>	Record<string, QueryDefinition>
TUpdates extends Record<string, UpdateDefinition>	Record<string, UpdateDefinition>

Properties

Property	Modifier	Type	Defined in
activities?	readonly	TActivities	types.ts:61
input	readonly	AnySchema	types.ts:59
output	readonly	AnySchema	types.ts:60
queries?	readonly	TQueries	types.ts:63
signals?	readonly	TSignals	types.ts:62
updates?	readonly	TUpdates	types.ts:64

Functions

defineActivity()

function defineActivity<TActivity>(definition): TActivity;

Defined in: builder.ts:43

Define a Temporal activity with type-safe input and output schemas.

Activities are the building blocks of Temporal workflows that execute business logic and interact with external services. This function preserves TypeScript types while providing a consistent structure for activity definitions.

Type Parameters

Type Parameter	Description
TActivity extends ActivityDefinition	The activity definition type with input/output schemas

Parameters

Parameter	Type	Description
definition	TActivity	The activity definition containing input and output schemas

Returns

TActivity

The same definition with preserved types for type inference

Example

import { defineActivity } from '@temporal-contract/contract';
import { z } from 'zod';

export const sendEmail = defineActivity({
  input: z.object({
    to: z.string().email(),
    subject: z.string(),
    body: z.string(),
  }),
  output: z.object({
    messageId: z.string(),
    sentAt: z.date(),
  }),
});

---

defineContract()

function defineContract<TContract>(definition): TContract;

Defined in: builder.ts:226

Define a complete Temporal contract with type-safe workflows and activities.

A contract is the central definition that ties together your Temporal application's workflows and activities. It provides:

• Type safety across client, worker, and workflow code
• Automatic validation at runtime
• Compile-time verification of implementations
• Clear API boundaries and documentation

The contract validates the structure and ensures:

• Task queue is specified
• At least one workflow is defined
• Valid JavaScript identifiers are used
• No conflicts between global and workflow-specific activities
• All schemas implement the Standard Schema specification

Type Parameters

Type Parameter	Description
TContract extends ContractDefinition	The contract definition type

Parameters

Parameter	Type	Description
definition	TContract	The complete contract definition

Returns

TContract

The same definition with preserved types for type inference

Throws

If the contract structure is invalid

Example

import { defineContract } from '@temporal-contract/contract';
import { z } from 'zod';

export const myContract = defineContract({
  taskQueue: 'orders',
  workflows: {
    processOrder: {
      input: z.object({ orderId: z.string() }),
      output: z.object({ success: z.boolean() }),
      activities: {
        chargePayment: {
          input: z.object({ amount: z.number() }),
          output: z.object({ transactionId: z.string() }),
        },
      },
    },
  },
  // Optional global activities shared across workflows
  activities: {
    logEvent: {
      input: z.object({ message: z.string() }),
      output: z.void(),
    },
  },
});

---

defineQuery()

function defineQuery<TQuery>(definition): TQuery;

Defined in: builder.ts:100

Define a Temporal query with type-safe input and output schemas.

Queries allow you to read the current state of a running workflow without modifying it. They are synchronous and should not perform any mutations.

Type Parameters

Type Parameter	Description
TQuery extends QueryDefinition	The query definition type with input/output schemas

Parameters

Parameter	Type	Description
definition	TQuery	The query definition containing input and output schemas

Returns

TQuery

The same definition with preserved types for type inference

Example

import { defineQuery } from '@temporal-contract/contract';
import { z } from 'zod';

export const getOrderStatus = defineQuery({
  input: z.object({ orderId: z.string() }),
  output: z.object({
    status: z.enum(['pending', 'processing', 'completed', 'failed']),
    updatedAt: z.date(),
  }),
});

---

defineSignal()

function defineSignal<TSignal>(definition): TSignal;

Defined in: builder.ts:72

Define a Temporal signal with type-safe input schema.

Signals are asynchronous messages sent to running workflows to update their state or trigger certain behaviors. This function ensures type safety for signal payloads.

Type Parameters

Type Parameter	Description
TSignal extends SignalDefinition	The signal definition type with input schema

Parameters

Parameter	Type	Description
definition	TSignal	The signal definition containing input schema

Returns

TSignal

The same definition with preserved types for type inference

Example

import { defineSignal } from '@temporal-contract/contract';
import { z } from 'zod';

export const approveOrder = defineSignal({
  input: z.object({
    orderId: z.string(),
    approvedBy: z.string(),
  }),
});

---

defineUpdate()

function defineUpdate<TUpdate>(definition): TUpdate;

Defined in: builder.ts:132

Define a Temporal update with type-safe input and output schemas.

Updates are similar to signals but return a value and wait for the workflow to process them before completing. They provide a synchronous way to modify workflow state and get immediate feedback.

Type Parameters

Type Parameter	Description
TUpdate extends UpdateDefinition	The update definition type with input/output schemas

Parameters

Parameter	Type	Description
definition	TUpdate	The update definition containing input and output schemas

Returns

TUpdate

The same definition with preserved types for type inference

Example

import { defineUpdate } from '@temporal-contract/contract';
import { z } from 'zod';

export const updateOrderQuantity = defineUpdate({
  input: z.object({
    orderId: z.string(),
    newQuantity: z.number().positive(),
  }),
  output: z.object({
    success: z.boolean(),
    totalPrice: z.number(),
  }),
});

---

defineWorkflow()

function defineWorkflow<TWorkflow>(definition): TWorkflow;

Defined in: builder.ts:169

Define a Temporal workflow with type-safe input, output, and associated operations.

Workflows are durable functions that orchestrate activities, handle timeouts, and manage long-running processes. This function provides type safety for the entire workflow definition including activities, signals, queries, and updates.

Type Parameters

Type Parameter	Description
TWorkflow extends WorkflowDefinition	The workflow definition type with all associated schemas

Parameters

Parameter	Type	Description
definition	TWorkflow	The workflow definition containing input, output, and operations

Returns

TWorkflow

The same definition with preserved types for type inference

Example

import { defineWorkflow, defineActivity, defineSignal } from '@temporal-contract/contract';
import { z } from 'zod';

export const processOrder = defineWorkflow({
  input: z.object({ orderId: z.string() }),
  output: z.object({ success: z.boolean() }),
  activities: {
    validatePayment: defineActivity({
      input: z.object({ orderId: z.string() }),
      output: z.object({ valid: z.boolean() }),
    }),
  },
  signals: {
    cancel: defineSignal({
      input: z.object({ reason: z.string() }),
    }),
  },
});