@temporal-contract/contract 0.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+
+> @temporal-contract/contract@0.0.1 build /home/runner/work/temporal-contract/temporal-contract/packages/contract
+> tsdown src/index.ts --format cjs,esm --dts --clean
+
+ℹ tsdown v0.17.2 powered by rolldown v1.0.0-beta.53
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ [CJS] dist/index.cjs  5.96 kB │ gzip: 1.51 kB
+ℹ [CJS] 1 files, total: 5.96 kB
+ℹ [CJS] dist/index.d.cts  15.50 kB │ gzip: 2.50 kB
+ℹ [CJS] 1 files, total: 15.50 kB
+ℹ [ESM] dist/index.mjs     5.69 kB │ gzip: 1.49 kB
+ℹ [ESM] dist/index.d.mts  15.50 kB │ gzip: 2.50 kB
+ℹ [ESM] 2 files, total: 21.19 kB
+✔ Build complete in 2205ms
+✔ Build complete in 2206ms

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Benoit TRAVERS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# @temporal-contract/contract
+
+> Contract builder and type definitions for Temporal workflows and activities
+
+**Core package** for defining type-safe contracts with Zod schemas.
+
+## Installation
+
+```bash
+pnpm add @temporal-contract/contract zod
+```
+
+## What's Included
+
+- **Contract builder** — `defineContract()` for creating type-safe contracts
+- **Type utilities** — Helper types for cleaner implementations
+- **Helper functions** — Optional helpers for standalone definitions
+
+## Usage
+
+```typescript
+import { z } from 'zod';
+import { defineContract } from '@temporal-contract/contract';
+
+export const myContract = defineContract({
+  taskQueue: 'my-service',
+  workflows: {
+    processOrder: {
+      input: z.object({
+        orderId: z.string(),
+        items: z.array(z.object({
+          productId: z.string(),
+          quantity: z.number(),
+        })),
+      }),
+      output: z.object({
+        status: z.enum(['success', 'failed']),
+        totalAmount: z.number(),
+      }),
+      activities: {
+        processPayment: {
+          input: z.object({ amount: z.number() }),
+          output: z.object({ transactionId: z.string() }),
+        },
+      },
+    },
+  },
+});
+```
+
+## Quick Start
+
+### Define a Contract
+
+```typescript
+import { defineContract } from '@temporal-contract/contract';
+import { z } from 'zod';
+
+export const myContract = defineContract({
+  taskQueue: 'my-service',
+
+  // Global activities (available in all workflows)
+  activities: {
+    sendEmail: {
+      input: z.object({ to: z.string(), subject: z.string() }),
+      output: z.object({ sent: z.boolean() }),
+    },
+  },
+
+  // Workflows
+  workflows: {
+    processOrder: {
+      input: z.object({ orderId: z.string() }),
+      output: z.object({ status: z.string() }),
+
+      // Workflow-specific activities
+      activities: {
+        processPayment: {
+          input: z.object({ amount: z.number() }),
+          output: z.object({ transactionId: z.string() }),
+        },
+      },
+    },
+  },
+});
+```
+
+### Helper Functions (Optional)
+
+For standalone definitions outside a contract:
+
+```typescript
+import { defineActivity, defineSignal, defineQuery, defineUpdate } from '@temporal-contract/contract';
+
+// Standalone activity
+const sendEmail = defineActivity({
+  input: z.object({ to: z.string() }),
+  output: z.object({ sent: z.boolean() }),
+});
+
+// Signal, query, update
+const cancelOrder = defineSignal({ input: z.object({ reason: z.string() }) });
+const getStatus = defineQuery({ input: z.void(), output: z.object({ status: z.string() }) });
+const updateAmount = defineUpdate({ input: z.number(), output: z.boolean() });
+```
+
+## Type Utilities\n\nHelper types for implementing activities with full type inference:\n\n### Activity Handlers\n\n`typescript\nimport type { ActivityHandler, WorkflowActivityHandler } from '@temporal-contract/contract';\n\n// Global activity\nconst sendEmail: ActivityHandler<typeof myContract, 'sendEmail'> = \n  async ({ to, subject }) => {\n    await emailService.send({ to, subject });\n    return { sent: true };\n  };\n\n// Workflow-specific activity\nconst processPayment: WorkflowActivityHandler<typeof myContract, 'processOrder', 'processPayment'> = \n  async ({ amount }) => {\n    const txId = await paymentGateway.charge(amount);\n    return { transactionId: txId };\n  };\n`\n\n### Contract Introspection\n\n`typescript\nimport type { InferWorkflowNames, InferActivityNames } from '@temporal-contract/contract';\n\ntype Workflows = InferWorkflowNames<typeof myContract>;  // \"processOrder\" | ...\ntype Activities = InferActivityNames<typeof myContract>;  // \"sendEmail\" | ...\n`\n\nSee [Activity Handlers documentation](../../docs/ACTIVITY_HANDLERS.md) for details.\n\n---\n\n## Learn More\n\n- [Main README](../../README.md) \u2014 Quick start guide\n- [Worker Implementation](../../docs/CONTRACT_HANDLER.md) \u2014 Implementing workers\n- [Activity Handlers](../../docs/ACTIVITY_HANDLERS.md) \u2014 Type utility details\n\n## License\n\nMIT

package/dist/index.cjs

@@ -0,0 +1,190 @@
+let zod = require("zod");
+
+//#region src/builder.ts
+/**
+* Schema for validating JavaScript identifiers (workflow names, activity names, etc.)
+* Allows: letters, digits, underscore, dollar sign
+* Must start with: letter, underscore, or dollar sign
+*/
+const identifierSchema = zod.z.string().min(1).regex(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/, "must be a valid JavaScript identifier");
+/**
+* Extract clean error message from Zod validation error
+*/
+const getCleanErrorMessage = (error) => {
+	try {
+		const parsed = JSON.parse(error.message);
+		if (Array.isArray(parsed) && parsed.length > 0) {
+			const firstError = parsed[0];
+			if (firstError?.code === "invalid_key" && firstError?.issues && firstError.issues.length > 0) {
+				const nestedError = firstError.issues[0];
+				if (nestedError?.message) return nestedError.message;
+			}
+			if (firstError?.message) return firstError.message;
+		}
+	} catch {}
+	return error.message;
+};
+/**
+* Schema for validating activity definitions
+* Checks that input and output are Zod schemas
+*/
+const activityDefinitionSchema = zod.z.object({
+	input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }),
+	output: zod.z.instanceof(zod.z.ZodType, { message: "output must be a Zod schema" })
+});
+/**
+* Schema for validating signal definitions
+*/
+const signalDefinitionSchema = zod.z.object({ input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }) });
+/**
+* Schema for validating query definitions
+*/
+const queryDefinitionSchema = zod.z.object({
+	input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }),
+	output: zod.z.instanceof(zod.z.ZodType, { message: "output must be a Zod schema" })
+});
+/**
+* Schema for validating update definitions
+*/
+const updateDefinitionSchema = zod.z.object({
+	input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }),
+	output: zod.z.instanceof(zod.z.ZodType, { message: "output must be a Zod schema" })
+});
+/**
+* Schema for validating workflow definitions
+*/
+const workflowDefinitionSchema = zod.z.object({
+	input: zod.z.instanceof(zod.z.ZodType, { message: "input must be a Zod schema" }),
+	output: zod.z.instanceof(zod.z.ZodType, { message: "output must be a Zod schema" }),
+	activities: zod.z.record(identifierSchema, activityDefinitionSchema).optional(),
+	signals: zod.z.record(identifierSchema, signalDefinitionSchema).optional(),
+	queries: zod.z.record(identifierSchema, queryDefinitionSchema).optional(),
+	updates: zod.z.record(identifierSchema, updateDefinitionSchema).optional()
+});
+/**
+* Schema for validating a contract definition structure
+*/
+const contractValidationSchema = zod.z.object({
+	taskQueue: zod.z.string().trim().min(1, "taskQueue cannot be empty"),
+	workflows: zod.z.record(identifierSchema, workflowDefinitionSchema).refine((workflows) => Object.keys(workflows).length > 0, { message: "at least one workflow is required" }),
+	activities: zod.z.record(identifierSchema, activityDefinitionSchema).optional()
+}).superRefine((contract, ctx) => {
+	if (!contract.activities) return;
+	for (const [workflowName, workflow] of Object.entries(contract.workflows)) if (workflow.activities) {
+		for (const activityName of Object.keys(workflow.activities)) if (activityName in contract.activities) {
+			ctx.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: `workflow "${workflowName}" has activity "${activityName}" that conflicts with a global activity. Consider renaming the workflow-specific activity or removing the global activity "${activityName}".`
+			});
+			return;
+		}
+	}
+});
+/**
+* Builder for creating activity definitions
+*
+* @example
+* ```ts
+* const myActivity = defineActivity({
+*   input: z.tuple([z.object({ name: z.string() })]),
+*   output: z.object({ greeting: z.string() }),
+* });
+* ```
+*/
+const defineActivity = (definition) => {
+	return definition;
+};
+/**
+* Builder for creating signal definitions
+*
+* @example
+* ```ts
+* const mySignal = defineSignal({
+*   input: z.object({ message: z.string() }),
+* });
+* ```
+*/
+const defineSignal = (definition) => {
+	return definition;
+};
+/**
+* Builder for creating query definitions
+*
+* @example
+* ```ts
+* const myQuery = defineQuery({
+*   input: z.object({ id: z.string() }),
+*   output: z.object({ status: z.string() }),
+* });
+* ```
+*/
+const defineQuery = (definition) => {
+	return definition;
+};
+/**
+* Builder for creating update definitions
+*
+* @example
+* ```ts
+* const myUpdate = defineUpdate({
+*   input: z.object({ value: z.number() }),
+*   output: z.object({ newValue: z.number() }),
+* });
+* ```
+*/
+const defineUpdate = (definition) => {
+	return definition;
+};
+/**
+* Builder for creating workflow definitions
+*
+* @example
+* ```ts
+* const myWorkflow = defineWorkflow({
+*   input: z.tuple([z.object({ orderId: z.string() })]),
+*   output: z.object({ status: z.string() }),
+*   activities: {
+*     processPayment: defineActivity({
+*       input: z.tuple([z.object({ amount: z.number() })]),
+*       output: z.object({ success: z.boolean() }),
+*     }),
+*   },
+* });
+* ```
+*/
+const defineWorkflow = (definition) => {
+	return definition;
+};
+/**
+* Builder for creating a complete contract
+*
+* @example
+* ```ts
+* const myContract = defineContract({
+*   taskQueue: 'my-service',
+*   workflows: {
+*     processOrder: defineWorkflow({ ... }),
+*     sendNotification: defineWorkflow({ ... }),
+*   },
+*   activities: {
+*     sendEmail: defineActivity({ ... }),
+*   },
+* });
+* ```
+*/
+const defineContract = (definition) => {
+	const validationResult = contractValidationSchema.safeParse(definition);
+	if (!validationResult.success) {
+		const cleanMessage = getCleanErrorMessage(validationResult.error);
+		throw new Error(`Contract error: ${cleanMessage}`);
+	}
+	return definition;
+};
+
+//#endregion
+exports.defineActivity = defineActivity;
+exports.defineContract = defineContract;
+exports.defineQuery = defineQuery;
+exports.defineSignal = defineSignal;
+exports.defineUpdate = defineUpdate;
+exports.defineWorkflow = defineWorkflow;

package/dist/index.d.cts

@@ -0,0 +1,351 @@
+import { z } from "zod";
+
+//#region src/types.d.ts
+
+/**
+ * Base types for validation schemas
+ * Constrained to avoid implicit any types
+ */
+type AnyZodSchema = z.ZodType<unknown, unknown>;
+/**
+ * Definition of an activity
+ */
+interface ActivityDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+  readonly input: TInput;
+  readonly output: TOutput;
+}
+/**
+ * Definition of a signal
+ */
+interface SignalDefinition<TInput extends AnyZodSchema = AnyZodSchema> {
+  readonly input: TInput;
+}
+/**
+ * Definition of a query
+ */
+interface QueryDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+  readonly input: TInput;
+  readonly output: TOutput;
+}
+/**
+ * Definition of an update
+ */
+interface UpdateDefinition<TInput extends AnyZodSchema = AnyZodSchema, TOutput extends AnyZodSchema = AnyZodSchema> {
+  readonly input: TInput;
+  readonly output: TOutput;
+}
+/**
+ * Definition of a workflow
+ */
+interface WorkflowDefinition<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>> {
+  readonly input: AnyZodSchema;
+  readonly output: AnyZodSchema;
+  readonly activities?: TActivities;
+  readonly signals?: TSignals;
+  readonly queries?: TQueries;
+  readonly updates?: TUpdates;
+}
+/**
+ * Contract definition containing workflows and optional global activities
+ */
+interface ContractDefinition<TWorkflows extends Record<string, WorkflowDefinition> = Record<string, WorkflowDefinition>, TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>> {
+  readonly taskQueue: string;
+  readonly workflows: TWorkflows;
+  readonly activities?: TActivities;
+}
+/**
+ * Infer input type from a definition (worker perspective)
+ * Worker receives z.output (after input schema parsing/transformation)
+ */
+type WorkerInferInput<T extends {
+  input: AnyZodSchema;
+}> = z.output<T["input"]>;
+/**
+ * Infer output type from a definition (worker perspective)
+ * Worker returns z.input (before output schema parsing/transformation)
+ */
+type WorkerInferOutput<T extends {
+  output: AnyZodSchema;
+}> = z.input<T["output"]>;
+/**
+ * Infer input type from a definition (client perspective)
+ * Client sends z.input (before input schema parsing/transformation)
+ */
+type ClientInferInput<T extends {
+  input: AnyZodSchema;
+}> = z.input<T["input"]>;
+/**
+ * Infer output type from a definition (client perspective)
+ * Client receives z.output (after output schema parsing/transformation)
+ */
+type ClientInferOutput<T extends {
+  output: AnyZodSchema;
+}> = z.output<T["output"]>;
+/**
+ * WORKER PERSPECTIVE
+ * Worker receives z.output of input (parsed data) and returns z.input of output (raw data)
+ */
+/**
+ * Infer workflow function signature from worker perspective
+ * Worker receives z.input and returns z.output
+ */
+type WorkerInferWorkflow<TWorkflow extends WorkflowDefinition> = (args: WorkerInferInput<TWorkflow>) => Promise<WorkerInferOutput<TWorkflow>>;
+/**
+ * Infer activity function signature from worker perspective
+ * Worker receives z.input and returns z.output
+ */
+type WorkerInferActivity<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
+/**
+ * Infer signal handler signature from worker perspective
+ * Worker receives z.input
+ */
+type WorkerInferSignal<TSignal extends SignalDefinition> = (args: WorkerInferInput<TSignal>) => Promise<void>;
+/**
+ * Infer query handler signature from worker perspective
+ * Worker receives z.input and returns z.output
+ */
+type WorkerInferQuery<TQuery extends QueryDefinition> = (args: WorkerInferInput<TQuery>) => Promise<WorkerInferOutput<TQuery>>;
+/**
+ * Infer update handler signature from worker perspective
+ * Worker receives z.input and returns z.output
+ */
+type WorkerInferUpdate<TUpdate extends UpdateDefinition> = (args: WorkerInferInput<TUpdate>) => Promise<WorkerInferOutput<TUpdate>>;
+/**
+ * CLIENT PERSPECTIVE
+ * Client sends z.output and receives z.input
+ */
+/**
+ * Infer workflow function signature from client perspective
+ * Client sends z.output and receives z.input
+ */
+type ClientInferWorkflow<TWorkflow extends WorkflowDefinition> = (args: ClientInferInput<TWorkflow>) => Promise<ClientInferOutput<TWorkflow>>;
+/**
+ * Infer activity function signature from client perspective
+ * Client sends z.output and receives z.input
+ */
+type ClientInferActivity<TActivity extends ActivityDefinition> = (args: ClientInferInput<TActivity>) => Promise<ClientInferOutput<TActivity>>;
+/**
+ * Infer signal handler signature from client perspective
+ * Client sends z.output
+ */
+type ClientInferSignal<TSignal extends SignalDefinition> = (args: ClientInferInput<TSignal>) => Promise<void>;
+/**
+ * Infer query handler signature from client perspective
+ * Client sends z.output and receives z.input
+ */
+type ClientInferQuery<TQuery extends QueryDefinition> = (args: ClientInferInput<TQuery>) => Promise<ClientInferOutput<TQuery>>;
+/**
+ * Infer update handler signature from client perspective
+ * Client sends z.output and receives z.input
+ */
+type ClientInferUpdate<TUpdate extends UpdateDefinition> = (args: ClientInferInput<TUpdate>) => Promise<ClientInferOutput<TUpdate>>;
+/**
+ * WORKER PERSPECTIVE - Contract-level types
+ */
+/**
+ * Infer all workflows from a contract (worker perspective)
+ */
+type WorkerInferWorkflows<TContract extends ContractDefinition> = { [K in keyof TContract["workflows"]]: WorkerInferWorkflow<TContract["workflows"][K]> };
+/**
+ * Infer all activities from a contract (worker perspective)
+ */
+type WorkerInferActivities<TContract extends ContractDefinition> = TContract["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof TContract["activities"]]: WorkerInferActivity<TContract["activities"][K]> } : {};
+/**
+ * Infer activities from a workflow definition (worker perspective)
+ */
+type WorkerInferWorkflowActivities<T extends WorkflowDefinition> = T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: WorkerInferActivity<T["activities"][K]> } : {};
+/**
+ * Infer signals from a workflow definition (worker perspective)
+ */
+type WorkerInferWorkflowSignals<T extends WorkflowDefinition> = T["signals"] extends Record<string, SignalDefinition> ? { [K in keyof T["signals"]]: WorkerInferSignal<T["signals"][K]> } : {};
+/**
+ * Infer queries from a workflow definition (worker perspective)
+ */
+type WorkerInferWorkflowQueries<T extends WorkflowDefinition> = T["queries"] extends Record<string, QueryDefinition> ? { [K in keyof T["queries"]]: WorkerInferQuery<T["queries"][K]> } : {};
+/**
+ * Infer updates from a workflow definition (worker perspective)
+ */
+type WorkerInferWorkflowUpdates<T extends WorkflowDefinition> = T["updates"] extends Record<string, UpdateDefinition> ? { [K in keyof T["updates"]]: WorkerInferUpdate<T["updates"][K]> } : {};
+/**
+ * Infer all activities available in a workflow context (worker perspective)
+ * Combines workflow-specific activities with global activities
+ */
+type WorkerInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = WorkerInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & WorkerInferActivities<TContract>;
+/**
+ * CLIENT PERSPECTIVE - Contract-level types
+ */
+/**
+ * Infer all workflows from a contract (client perspective)
+ */
+type ClientInferWorkflows<TContract extends ContractDefinition> = { [K in keyof TContract["workflows"]]: ClientInferWorkflow<TContract["workflows"][K]> };
+/**
+ * Infer all activities from a contract (client perspective)
+ */
+type ClientInferActivities<TContract extends ContractDefinition> = TContract["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof TContract["activities"]]: ClientInferActivity<TContract["activities"][K]> } : {};
+/**
+ * Infer activities from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowActivities<T extends WorkflowDefinition> = T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: ClientInferActivity<T["activities"][K]> } : {};
+/**
+ * Infer signals from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowSignals<T extends WorkflowDefinition> = T["signals"] extends Record<string, SignalDefinition> ? { [K in keyof T["signals"]]: ClientInferSignal<T["signals"][K]> } : {};
+/**
+ * Infer queries from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowQueries<T extends WorkflowDefinition> = T["queries"] extends Record<string, QueryDefinition> ? { [K in keyof T["queries"]]: ClientInferQuery<T["queries"][K]> } : {};
+/**
+ * Infer updates from a workflow definition (client perspective)
+ */
+type ClientInferWorkflowUpdates<T extends WorkflowDefinition> = T["updates"] extends Record<string, UpdateDefinition> ? { [K in keyof T["updates"]]: ClientInferUpdate<T["updates"][K]> } : {};
+/**
+ * Infer all activities available in a workflow context (client perspective)
+ * Combines workflow-specific activities with global activities
+ */
+type ClientInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = ClientInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & ClientInferActivities<TContract>;
+/**
+ * UTILITY TYPES FOR ACTIVITY HANDLERS
+ */
+/**
+ * Extract workflow names from a contract as a union type
+ *
+ * @example
+ * ```typescript
+ * type MyWorkflowNames = InferWorkflowNames<typeof myContract>;
+ * // "processOrder" | "sendNotification"
+ * ```
+ */
+type InferWorkflowNames<TContract extends ContractDefinition> = keyof TContract["workflows"] & string;
+/**
+ * Extract activity names from a contract (global activities) as a union type
+ *
+ * @example
+ * ```typescript
+ * type MyActivityNames = InferActivityNames<typeof myContract>;
+ * // "log" | "sendEmail"
+ * ```
+ */
+type InferActivityNames<TContract extends ContractDefinition> = TContract["activities"] extends Record<string, ActivityDefinition> ? keyof TContract["activities"] & string : never;
+/**
+ * Extract all workflows from a contract with their definitions
+ *
+ * @example
+ * ```typescript
+ * type MyWorkflows = InferContractWorkflows<typeof myContract>;
+ * ```
+ */
+type InferContractWorkflows<TContract extends ContractDefinition> = TContract["workflows"];
+/**
+ * Infer the handler type for a global activity from a contract
+ *
+ * @example
+ * ```typescript
+ * const log: ActivityHandler<typeof myContract, "log"> = async ({ level, message }) => {
+ *   logger[level](message);
+ * };
+ * ```
+ */
+type ActivityHandler<TContract extends ContractDefinition, TActivityName extends keyof TContract["activities"]> = TContract["activities"] extends Record<string, ActivityDefinition> ? (args: WorkerInferInput<TContract["activities"][TActivityName]>) => Promise<WorkerInferOutput<TContract["activities"][TActivityName]>> : never;
+/**
+ * Infer the handler type for a workflow-specific activity from a contract
+ *
+ * @example
+ * ```typescript
+ * const processPayment: WorkflowActivityHandler<
+ *   typeof myContract,
+ *   "processOrder",
+ *   "processPayment"
+ * > = async ({ customerId, amount }) => {
+ *   // Implementation
+ *   return { transactionId, status: "success" as const, paidAmount: amount };
+ * };
+ * ```
+ */
+type WorkflowActivityHandler<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"], TActivityName extends keyof TContract["workflows"][TWorkflowName]["activities"]> = TContract["workflows"][TWorkflowName]["activities"] extends Record<string, ActivityDefinition> ? (args: WorkerInferInput<TContract["workflows"][TWorkflowName]["activities"][TActivityName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]["activities"][TActivityName]>> : never;
+//#endregion
+//#region src/builder.d.ts
+/**
+ * Builder for creating activity definitions
+ *
+ * @example
+ * ```ts
+ * const myActivity = defineActivity({
+ *   input: z.tuple([z.object({ name: z.string() })]),
+ *   output: z.object({ greeting: z.string() }),
+ * });
+ * ```
+ */
+declare const defineActivity: <TActivity extends ActivityDefinition>(definition: TActivity) => TActivity;
+/**
+ * Builder for creating signal definitions
+ *
+ * @example
+ * ```ts
+ * const mySignal = defineSignal({
+ *   input: z.object({ message: z.string() }),
+ * });
+ * ```
+ */
+declare const defineSignal: <TSignal extends SignalDefinition>(definition: TSignal) => TSignal;
+/**
+ * Builder for creating query definitions
+ *
+ * @example
+ * ```ts
+ * const myQuery = defineQuery({
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ status: z.string() }),
+ * });
+ * ```
+ */
+declare const defineQuery: <TQuery extends QueryDefinition>(definition: TQuery) => TQuery;
+/**
+ * Builder for creating update definitions
+ *
+ * @example
+ * ```ts
+ * const myUpdate = defineUpdate({
+ *   input: z.object({ value: z.number() }),
+ *   output: z.object({ newValue: z.number() }),
+ * });
+ * ```
+ */
+declare const defineUpdate: <TUpdate extends UpdateDefinition>(definition: TUpdate) => TUpdate;
+/**
+ * Builder for creating workflow definitions
+ *
+ * @example
+ * ```ts
+ * const myWorkflow = defineWorkflow({
+ *   input: z.tuple([z.object({ orderId: z.string() })]),
+ *   output: z.object({ status: z.string() }),
+ *   activities: {
+ *     processPayment: defineActivity({
+ *       input: z.tuple([z.object({ amount: z.number() })]),
+ *       output: z.object({ success: z.boolean() }),
+ *     }),
+ *   },
+ * });
+ * ```
+ */
+declare const defineWorkflow: <TWorkflow extends WorkflowDefinition>(definition: TWorkflow) => TWorkflow;
+/**
+ * Builder for creating a complete contract
+ *
+ * @example
+ * ```ts
+ * const myContract = defineContract({
+ *   taskQueue: 'my-service',
+ *   workflows: {
+ *     processOrder: defineWorkflow({ ... }),
+ *     sendNotification: defineWorkflow({ ... }),
+ *   },
+ *   activities: {
+ *     sendEmail: defineActivity({ ... }),
+ *   },
+ * });
+ * ```
+ */
+declare const defineContract: <TContract extends ContractDefinition>(definition: TContract) => TContract;
+//#endregion
+export { type ActivityDefinition, type ActivityHandler, type AnyZodSchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };