@temporal-contract/worker 0.0.5 → 0.0.6

package/dist/errors-BqYWpdvd.d.cts

@@ -0,0 +1,137 @@
+import { AnySchema } from "@temporal-contract/contract";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/types.d.ts
+
+/**
+ * Infer input type from a definition (worker perspective)
+ * Worker receives the output type (after input schema parsing/transformation)
+ */
+type WorkerInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["input"]>;
+/**
+ * Infer output type from a definition (worker perspective)
+ * Worker returns the input type (before output schema parsing/transformation)
+ */
+type WorkerInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferInput<T["output"]>;
+/**
+ * Infer input type from a definition (client perspective)
+ * Client sends the input type (before input schema parsing/transformation)
+ */
+type ClientInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferInput<T["input"]>;
+/**
+ * Infer output type from a definition (client perspective)
+ * Client receives the output type (after output schema parsing/transformation)
+ */
+type ClientInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["output"]>;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Base error class for worker errors
+ */
+declare abstract class WorkerError extends Error {
+  protected constructor(message: string, cause?: unknown);
+}
+/**
+ * Error thrown when an activity definition is not found in the contract
+ */
+declare class ActivityDefinitionNotFoundError extends WorkerError {
+  readonly activityName: string;
+  readonly availableDefinitions: readonly string[];
+  constructor(activityName: string, availableDefinitions?: readonly string[]);
+}
+/**
+ * Error thrown when activity input validation fails
+ */
+declare class ActivityInputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when activity output validation fails
+ */
+declare class ActivityOutputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow input validation fails
+ */
+declare class WorkflowInputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow output validation fails
+ */
+declare class WorkflowOutputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when signal input validation fails
+ */
+declare class SignalInputValidationError extends WorkerError {
+  readonly signalName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(signalName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query input validation fails
+ */
+declare class QueryInputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query output validation fails
+ */
+declare class QueryOutputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update input validation fails
+ */
+declare class UpdateInputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update output validation fails
+ */
+declare class UpdateOutputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when a child workflow is not found in the contract
+ */
+declare class ChildWorkflowNotFoundError extends WorkerError {
+  readonly workflowName: string;
+  readonly availableWorkflows: readonly string[];
+  constructor(workflowName: string, availableWorkflows?: readonly string[]);
+}
+/**
+ * Generic error for child workflow operations
+ */
+declare class ChildWorkflowError extends WorkerError {
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };

package/dist/errors-C1RFkCuD.d.mts

@@ -0,0 +1,137 @@
+import { AnySchema } from "@temporal-contract/contract";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/types.d.ts
+
+/**
+ * Infer input type from a definition (worker perspective)
+ * Worker receives the output type (after input schema parsing/transformation)
+ */
+type WorkerInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["input"]>;
+/**
+ * Infer output type from a definition (worker perspective)
+ * Worker returns the input type (before output schema parsing/transformation)
+ */
+type WorkerInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferInput<T["output"]>;
+/**
+ * Infer input type from a definition (client perspective)
+ * Client sends the input type (before input schema parsing/transformation)
+ */
+type ClientInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferInput<T["input"]>;
+/**
+ * Infer output type from a definition (client perspective)
+ * Client receives the output type (after output schema parsing/transformation)
+ */
+type ClientInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["output"]>;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Base error class for worker errors
+ */
+declare abstract class WorkerError extends Error {
+  protected constructor(message: string, cause?: unknown);
+}
+/**
+ * Error thrown when an activity definition is not found in the contract
+ */
+declare class ActivityDefinitionNotFoundError extends WorkerError {
+  readonly activityName: string;
+  readonly availableDefinitions: readonly string[];
+  constructor(activityName: string, availableDefinitions?: readonly string[]);
+}
+/**
+ * Error thrown when activity input validation fails
+ */
+declare class ActivityInputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when activity output validation fails
+ */
+declare class ActivityOutputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow input validation fails
+ */
+declare class WorkflowInputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow output validation fails
+ */
+declare class WorkflowOutputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when signal input validation fails
+ */
+declare class SignalInputValidationError extends WorkerError {
+  readonly signalName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(signalName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query input validation fails
+ */
+declare class QueryInputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query output validation fails
+ */
+declare class QueryOutputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update input validation fails
+ */
+declare class UpdateInputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update output validation fails
+ */
+declare class UpdateOutputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when a child workflow is not found in the contract
+ */
+declare class ChildWorkflowNotFoundError extends WorkerError {
+  readonly workflowName: string;
+  readonly availableWorkflows: readonly string[];
+  constructor(workflowName: string, availableWorkflows?: readonly string[]);
+}
+/**
+ * Generic error for child workflow operations
+ */
+declare class ChildWorkflowError extends WorkerError {
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };

package/dist/errors-DjSZg-93.cjs

@@ -0,0 +1,227 @@
+
+//#region src/errors.ts
+/**
+* Base error class for worker errors
+*/
+var WorkerError = class extends Error {
+	constructor(message, cause) {
+		super(message, { cause });
+		this.name = "WorkerError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Error thrown when an activity definition is not found in the contract
+*/
+var ActivityDefinitionNotFoundError = class extends WorkerError {
+	constructor(activityName, availableDefinitions = []) {
+		const available = availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none";
+		super(`Activity definition not found for: "${activityName}". Available activities: ${available}`);
+		this.activityName = activityName;
+		this.availableDefinitions = availableDefinitions;
+		this.name = "ActivityDefinitionNotFoundError";
+	}
+};
+/**
+* Error thrown when activity input validation fails
+*/
+var ActivityInputValidationError = class extends WorkerError {
+	constructor(activityName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Activity "${activityName}" input validation failed: ${message}`);
+		this.activityName = activityName;
+		this.issues = issues;
+		this.name = "ActivityInputValidationError";
+	}
+};
+/**
+* Error thrown when activity output validation fails
+*/
+var ActivityOutputValidationError = class extends WorkerError {
+	constructor(activityName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Activity "${activityName}" output validation failed: ${message}`);
+		this.activityName = activityName;
+		this.issues = issues;
+		this.name = "ActivityOutputValidationError";
+	}
+};
+/**
+* Error thrown when workflow input validation fails
+*/
+var WorkflowInputValidationError = class extends WorkerError {
+	constructor(workflowName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Workflow "${workflowName}" input validation failed: ${message}`);
+		this.workflowName = workflowName;
+		this.issues = issues;
+		this.name = "WorkflowInputValidationError";
+	}
+};
+/**
+* Error thrown when workflow output validation fails
+*/
+var WorkflowOutputValidationError = class extends WorkerError {
+	constructor(workflowName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Workflow "${workflowName}" output validation failed: ${message}`);
+		this.workflowName = workflowName;
+		this.issues = issues;
+		this.name = "WorkflowOutputValidationError";
+	}
+};
+/**
+* Error thrown when signal input validation fails
+*/
+var SignalInputValidationError = class extends WorkerError {
+	constructor(signalName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Signal "${signalName}" input validation failed: ${message}`);
+		this.signalName = signalName;
+		this.issues = issues;
+		this.name = "SignalInputValidationError";
+	}
+};
+/**
+* Error thrown when query input validation fails
+*/
+var QueryInputValidationError = class extends WorkerError {
+	constructor(queryName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Query "${queryName}" input validation failed: ${message}`);
+		this.queryName = queryName;
+		this.issues = issues;
+		this.name = "QueryInputValidationError";
+	}
+};
+/**
+* Error thrown when query output validation fails
+*/
+var QueryOutputValidationError = class extends WorkerError {
+	constructor(queryName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Query "${queryName}" output validation failed: ${message}`);
+		this.queryName = queryName;
+		this.issues = issues;
+		this.name = "QueryOutputValidationError";
+	}
+};
+/**
+* Error thrown when update input validation fails
+*/
+var UpdateInputValidationError = class extends WorkerError {
+	constructor(updateName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Update "${updateName}" input validation failed: ${message}`);
+		this.updateName = updateName;
+		this.issues = issues;
+		this.name = "UpdateInputValidationError";
+	}
+};
+/**
+* Error thrown when update output validation fails
+*/
+var UpdateOutputValidationError = class extends WorkerError {
+	constructor(updateName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Update "${updateName}" output validation failed: ${message}`);
+		this.updateName = updateName;
+		this.issues = issues;
+		this.name = "UpdateOutputValidationError";
+	}
+};
+/**
+* Error thrown when a child workflow is not found in the contract
+*/
+var ChildWorkflowNotFoundError = class extends WorkerError {
+	constructor(workflowName, availableWorkflows = []) {
+		const available = availableWorkflows.length > 0 ? availableWorkflows.join(", ") : "none";
+		super(`Child workflow not found: "${workflowName}". Available workflows: ${available}`);
+		this.workflowName = workflowName;
+		this.availableWorkflows = availableWorkflows;
+		this.name = "ChildWorkflowNotFoundError";
+	}
+};
+/**
+* Generic error for child workflow operations
+*/
+var ChildWorkflowError = class extends WorkerError {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "ChildWorkflowError";
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ActivityDefinitionNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ActivityDefinitionNotFoundError;
+  }
+});
+Object.defineProperty(exports, 'ActivityInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return ActivityInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'ActivityOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return ActivityOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'ChildWorkflowError', {
+  enumerable: true,
+  get: function () {
+    return ChildWorkflowError;
+  }
+});
+Object.defineProperty(exports, 'ChildWorkflowNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ChildWorkflowNotFoundError;
+  }
+});
+Object.defineProperty(exports, 'QueryInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return QueryInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'QueryOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return QueryOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'SignalInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return SignalInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'UpdateInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return UpdateInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'UpdateOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return UpdateOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'WorkflowInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return WorkflowInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'WorkflowOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return WorkflowOutputValidationError;
+  }
+});

package/dist/worker.cjs

@@ -0,0 +1,65 @@
+let _temporalio_worker = require("@temporalio/worker");
+let node_url = require("node:url");
+let node_path = require("node:path");
+
+//#region src/worker.ts
+/**
+* Create a typed Temporal worker with contract-based configuration
+*
+* This helper simplifies worker creation by:
+* - Using the contract's task queue automatically
+* - Providing type-safe configuration
+*
+* @example
+* ```ts
+* import { NativeConnection } from '@temporalio/worker';
+* import { createWorker } from '@temporal-contract/worker/worker';
+* import { activities } from './activities';
+* import myContract from './contract';
+*
+* const connection = await NativeConnection.connect({
+*   address: 'localhost:7233',
+* });
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: require.resolve('./workflows'),
+*   activities,
+* });
+*
+* await worker.run();
+* ```
+*/
+async function createWorker(options) {
+	const { contract, activities, ...workerOptions } = options;
+	return await _temporalio_worker.Worker.create({
+		...workerOptions,
+		activities,
+		taskQueue: contract.taskQueue
+	});
+}
+/**
+* Helper to create a workflowsPath from a file URL
+*
+* Useful for creating the workflowsPath option when using ES modules
+*
+* @example
+* ```ts
+* import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+*   activities,
+* });
+* ```
+*/
+function workflowsPathFromURL(baseURL, relativePath) {
+	return (0, node_url.fileURLToPath)(new URL(`${relativePath}${(0, node_path.extname)(baseURL)}`, baseURL));
+}
+
+//#endregion
+exports.createWorker = createWorker;
+exports.workflowsPathFromURL = workflowsPathFromURL;

package/dist/worker.d.cts

@@ -0,0 +1,68 @@
+import { ActivitiesHandler } from "./activity.cjs";
+import { ContractDefinition } from "@temporal-contract/contract";
+import { Worker, WorkerOptions } from "@temporalio/worker";
+
+//#region src/worker.d.ts
+
+/**
+ * Options for creating a Temporal worker
+ */
+interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit<WorkerOptions, "activities" | "taskQueue"> {
+  /**
+   * The contract definition for this worker
+   */
+  contract: TContract;
+  /**
+   * Activities handler for this worker
+   */
+  activities: ActivitiesHandler<TContract>;
+}
+/**
+ * Create a typed Temporal worker with contract-based configuration
+ *
+ * This helper simplifies worker creation by:
+ * - Using the contract's task queue automatically
+ * - Providing type-safe configuration
+ *
+ * @example
+ * ```ts
+ * import { NativeConnection } from '@temporalio/worker';
+ * import { createWorker } from '@temporal-contract/worker/worker';
+ * import { activities } from './activities';
+ * import myContract from './contract';
+ *
+ * const connection = await NativeConnection.connect({
+ *   address: 'localhost:7233',
+ * });
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities,
+ * });
+ *
+ * await worker.run();
+ * ```
+ */
+declare function createWorker<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<Worker>;
+/**
+ * Helper to create a workflowsPath from a file URL
+ *
+ * Useful for creating the workflowsPath option when using ES modules
+ *
+ * @example
+ * ```ts
+ * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+ *   activities,
+ * });
+ * ```
+ */
+declare function workflowsPathFromURL(baseURL: string, relativePath: string): string;
+//#endregion
+export { CreateWorkerOptions, createWorker, workflowsPathFromURL };

package/dist/worker.d.mts

@@ -0,0 +1,68 @@
+import { ActivitiesHandler } from "./activity.mjs";
+import { Worker, WorkerOptions } from "@temporalio/worker";
+import { ContractDefinition } from "@temporal-contract/contract";
+
+//#region src/worker.d.ts
+
+/**
+ * Options for creating a Temporal worker
+ */
+interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit<WorkerOptions, "activities" | "taskQueue"> {
+  /**
+   * The contract definition for this worker
+   */
+  contract: TContract;
+  /**
+   * Activities handler for this worker
+   */
+  activities: ActivitiesHandler<TContract>;
+}
+/**
+ * Create a typed Temporal worker with contract-based configuration
+ *
+ * This helper simplifies worker creation by:
+ * - Using the contract's task queue automatically
+ * - Providing type-safe configuration
+ *
+ * @example
+ * ```ts
+ * import { NativeConnection } from '@temporalio/worker';
+ * import { createWorker } from '@temporal-contract/worker/worker';
+ * import { activities } from './activities';
+ * import myContract from './contract';
+ *
+ * const connection = await NativeConnection.connect({
+ *   address: 'localhost:7233',
+ * });
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities,
+ * });
+ *
+ * await worker.run();
+ * ```
+ */
+declare function createWorker<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<Worker>;
+/**
+ * Helper to create a workflowsPath from a file URL
+ *
+ * Useful for creating the workflowsPath option when using ES modules
+ *
+ * @example
+ * ```ts
+ * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+ *   activities,
+ * });
+ * ```
+ */
+declare function workflowsPathFromURL(baseURL: string, relativePath: string): string;
+//#endregion
+export { CreateWorkerOptions, createWorker, workflowsPathFromURL };