nestjs-temporal-core 3.0.10 → 3.0.12

package/dist/interfaces.d.ts

@@ -1,36 +1,51 @@
-import { ModuleMetadata, Type } from '@nestjs/common';
 export { RetryPolicy, Duration, SearchAttributes } from '@temporalio/common';
-export { ScheduleOverlapPolicy, WorkflowHandle, Client } from '@temporalio/client';
+export { WorkflowHandle, Client, ConnectionOptions as TemporalConnectionOptions, } from '@temporalio/client';
 export { Worker } from '@temporalio/worker';
-export interface ConnectionOptions {
+import { Type } from '@nestjs/common';
+import { ScheduleClient, ScheduleHandle } from '@temporalio/client';
+import { NativeConnection, Worker } from '@temporalio/worker';
+import { TypedSearchAttributes } from '@temporalio/common';
+import { TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
+export interface ClientConnectionOptions {
     address: string;
-    tls?: boolean | {
-        serverName?: string;
-        clientCertPair?: {
-            crt: Buffer;
-            key: Buffer;
-            ca?: Buffer;
-        };
-    };
-    apiKey?: string;
+    tls?: boolean | TLSConfig;
     metadata?: Record<string, string>;
+    apiKey?: string;
+    namespace?: string;
+}
+export type ConnectionOptions = import('@temporalio/client').ConnectionOptions;
+export interface RetryPolicyConfig {
+    maximumAttempts: number;
+    initialInterval: string;
+    maximumInterval: string;
+    backoffCoefficient: number;
+}
+export interface WorkerDefinition {
+    taskQueue: string;
+    workflowsPath?: string;
+    workflowBundle?: Record<string, unknown>;
+    activityClasses?: Array<Type<object>>;
+    autoStart?: boolean;
+    workerOptions?: WorkerCreateOptions;
 }
 export interface TemporalOptions extends LoggerConfig {
-    connection: {
+    connection?: {
         address: string;
         namespace?: string;
-        tls?: ConnectionOptions['tls'];
+        tls?: boolean | TLSConfig;
         apiKey?: string;
         metadata?: Record<string, string>;
     };
     taskQueue?: string;
     worker?: {
         workflowsPath?: string;
-        workflowBundle?: unknown;
-        activityClasses?: Array<Type<unknown>>;
+        workflowBundle?: Record<string, unknown>;
+        activityClasses?: Array<Type<object>>;
         autoStart?: boolean;
         workerOptions?: WorkerCreateOptions;
     };
+    workers?: WorkerDefinition[];
+    autoRestart?: boolean;
     isGlobal?: boolean;
     allowConnectionFailure?: boolean;
 }
@@ -47,29 +62,6 @@ export interface WorkerCreateOptions {
     maxConcurrentActivityTaskPolls?: number;
     enableLoggingInReplay?: boolean;
 }
-export interface RetryPolicyConfig {
-    maximumAttempts: number;
-    initialInterval: string;
-    maximumInterval: string;
-    backoffCoefficient: number;
-}
-export interface TemporalOptionsFactory {
-    createTemporalOptions(): Promise<TemporalOptions> | TemporalOptions;
-}
-export interface TemporalAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    useExisting?: Type<TemporalOptionsFactory>;
-    useClass?: Type<TemporalOptionsFactory>;
-    useFactory?: (...args: unknown[]) => Promise<TemporalOptions> | TemporalOptions;
-    inject?: (string | symbol | Type<unknown>)[];
-    isGlobal?: boolean;
-}
-export interface ClientConnectionOptions {
-    address: string;
-    tls?: unknown;
-    metadata?: Record<string, string>;
-    apiKey?: string;
-    namespace?: string;
-}
 export interface WorkerModuleOptions {
     connection?: {
         address?: string;
@@ -80,8 +72,8 @@ export interface WorkerModuleOptions {
     };
     taskQueue?: string;
     workflowsPath?: string;
-    workflowBundle?: unknown;
-    activityClasses?: Array<unknown>;
+    workflowBundle?: Record<string, unknown>;
+    activityClasses?: Array<Type<object>>;
     autoStart?: boolean;
     autoRestart?: boolean;
     allowWorkerFailure?: boolean;
@@ -89,36 +81,33 @@ export interface WorkerModuleOptions {
     enableLogger?: boolean;
     logLevel?: LogLevel;
 }
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'verbose';
 export interface GlobalLoggerConfig extends LoggerConfig {
     appName?: string;
     formatter?: (level: string, message: string, context: string, timestamp: string) => string;
     logToFile?: boolean;
     logFilePath?: string;
 }
-export interface SignalOptions {
-    name?: string;
-}
-export interface QueryOptions {
-    name?: string;
+export interface LoggerConfig {
+    enableLogger?: boolean;
+    logLevel?: LogLevel;
 }
-export interface StartWorkflowOptions {
-    taskQueue: string;
-    workflowId?: string;
-    signal?: {
-        name: string;
-        args?: unknown[];
-    };
-    [key: string]: unknown;
+export interface TemporalOptionsFactory {
+    createTemporalOptions(): Promise<TemporalOptions> | TemporalOptions;
 }
-export interface WorkflowExecutionContext {
-    workflowId: string;
-    runId: string;
-    workflowType: string;
-    taskQueue: string;
-    namespace: string;
+export interface TemporalAsyncOptions {
+    useExisting?: Type<TemporalOptionsFactory>;
+    useClass?: Type<TemporalOptionsFactory>;
+    useFactory?: (...args: unknown[]) => Promise<TemporalOptions> | TemporalOptions;
+    inject?: Array<string | symbol | Type<unknown>>;
+    imports?: Array<Type<unknown>>;
+    isGlobal?: boolean;
 }
-export interface ActivityOptions {
-    name?: string;
+export interface ActivityMethodMetadata {
+    name: string;
+    originalName: string;
+    options?: Record<string, string | number | boolean | object>;
+    handler: ActivityMethodHandler;
 }
 export interface ActivityMethodOptions {
     name?: string;
@@ -127,72 +116,27 @@ export interface ActivityMethodOptions {
 }
 export interface ActivityMetadata {
     name?: string;
-    options?: Record<string, unknown>;
+    options?: Record<string, string | number | boolean | object>;
 }
-export interface ScheduledOptions {
-    scheduleId: string;
-    cron?: string;
-    interval?: string;
-    description?: string;
-    taskQueue?: string;
-    timezone?: string;
-    overlapPolicy?: 'ALLOW_ALL' | 'SKIP' | 'BUFFER_ONE' | 'BUFFER_ALL' | 'CANCEL_OTHER';
-    startPaused?: boolean;
-    autoStart?: boolean;
-}
-export interface CronOptions extends Omit<ScheduledOptions, 'cron' | 'interval'> {
-    scheduleId: string;
-}
-export interface IntervalOptions extends Omit<ScheduledOptions, 'cron' | 'interval'> {
-    scheduleId: string;
+export interface ActivityOptions {
+    name?: string;
 }
-export type SignalMethodHandler = (...args: unknown[]) => void | Promise<void>;
-export type QueryMethodHandler = (...args: unknown[]) => unknown;
-export type ActivityMethodHandler = (...args: unknown[]) => unknown | Promise<unknown>;
-export interface SignalMethodInfo {
-    methodName: string;
-    signalName: string;
-    options: SignalOptions;
-    handler: SignalMethodHandler;
+export interface DiscoveryStats {
+    controllers: number;
+    methods: number;
+    signals: number;
+    queries: number;
+    workflows: number;
+    childWorkflows: number;
 }
 export interface QueryMethodInfo {
     methodName: string;
     queryName: string;
     options: QueryOptions;
-    handler: QueryMethodHandler;
-}
-export interface ScheduledMethodInfo {
-    methodName: string;
-    workflowName: string;
-    scheduleOptions: ScheduledOptions;
-    workflowOptions: StartWorkflowOptions;
     handler: (...args: unknown[]) => unknown | Promise<unknown>;
-    controllerInfo: {
-        name: string;
-        instance: object;
-    };
 }
-export interface ActivityMethodMetadata {
-    name: string;
-    originalName: string;
-    options?: Record<string, unknown>;
-    handler: ActivityMethodHandler;
-}
-export interface DiscoveryStats {
-    controllers: number;
-    methods: number;
-    scheduled: number;
-    signals: number;
-    queries: number;
-}
-export interface ScheduleStatus {
-    scheduleId: string;
-    workflowName: string;
-    isManaged: boolean;
-    isActive: boolean;
-    lastError?: string;
-    createdAt: Date;
-    lastUpdatedAt: Date;
+export interface QueryOptions {
+    name?: string;
 }
 export interface ScheduleStats {
     total: number;
@@ -200,17 +144,23 @@ export interface ScheduleStats {
     inactive: number;
     errors: number;
 }
-export interface WorkerStatus {
-    isInitialized: boolean;
-    isRunning: boolean;
-    isHealthy: boolean;
+export interface SignalMethodInfo {
+    methodName: string;
+    signalName: string;
+    options?: Record<string, string | number | boolean | object>;
+    handler: (...args: unknown[]) => unknown | Promise<unknown>;
+}
+export interface SignalOptions {
+    name?: string;
+}
+export interface StartWorkflowOptions {
     taskQueue: string;
-    namespace: string;
-    workflowSource: 'bundle' | 'filesystem' | 'none';
-    activitiesCount: number;
-    lastError?: string;
-    startedAt?: Date;
-    uptime?: number;
+    workflowId?: string;
+    signal?: {
+        name: string;
+        args?: unknown[];
+    };
+    [key: string]: unknown;
 }
 export interface SystemStatus {
     client: {
@@ -223,18 +173,60 @@ export interface SystemStatus {
         health?: string;
     };
     discovery: DiscoveryStats;
-    schedules: ScheduleStats;
 }
-export interface WorkflowParameterMetadata {
-    type: 'param' | 'context' | 'workflowId' | 'runId' | 'taskQueue';
-    index?: number;
-    extractAll?: boolean;
+export interface WorkerStatus {
+    isInitialized: boolean;
+    isRunning: boolean;
+    isHealthy: boolean;
+    taskQueue: string;
+    namespace: string;
+    workflowSource: 'bundle' | 'filesystem' | 'registered' | 'none';
+    activitiesCount: number;
+    workflowsCount?: number;
+    lastError?: string;
+    startedAt?: Date;
+    uptime?: number;
 }
-export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'verbose';
-export interface LoggerConfig {
-    enableLogger?: boolean;
-    logLevel?: LogLevel;
+export interface MultipleWorkersInfo {
+    workers: Map<string, WorkerStatus>;
+    totalWorkers: number;
+    runningWorkers: number;
+    healthyWorkers: number;
+}
+export interface CreateWorkerResult {
+    success: boolean;
+    taskQueue: string;
+    error?: Error;
+    worker?: Worker;
 }
+export interface WorkerInstance {
+    worker: Worker;
+    taskQueue: string;
+    namespace: string;
+    isRunning: boolean;
+    isInitialized: boolean;
+    lastError: string | null;
+    startedAt: Date | null;
+    restartCount: number;
+    activities: Map<string, Function>;
+    workflowSource: 'bundle' | 'filesystem' | 'registered' | 'none';
+}
+export interface SignalMethodMetadata {
+    signalName: string;
+    methodName: string;
+}
+export interface QueryMethodMetadata {
+    queryName: string;
+    methodName: string;
+}
+export interface ChildWorkflowMetadata {
+    workflowType: string | Type<unknown>;
+    options?: Record<string, string | number | boolean | object>;
+    propertyKey: string | symbol;
+}
+export type ActivityMethodHandler = (...args: unknown[]) => Promise<unknown> | unknown;
+export type QueryMethodHandler = (...args: unknown[]) => unknown;
+export type SignalMethodHandler = (...args: unknown[]) => void | Promise<void>;
 export interface ActivityModuleOptions extends LoggerConfig {
     activityClasses?: Array<Type<unknown>>;
     timeout?: string | number;
@@ -242,7 +234,7 @@ export interface ActivityModuleOptions extends LoggerConfig {
 }
 export interface ActivityInfo {
     className: string;
-    instance: object;
+    instance: Record<string, unknown>;
     targetClass: Type<unknown>;
     methods: Array<{
         name: string;
@@ -251,31 +243,652 @@ export interface ActivityInfo {
     }>;
     totalMethods: number;
 }
-export interface SchedulesModuleOptions extends LoggerConfig {
-    autoStart?: boolean;
-    defaultTimezone?: string;
-    global?: boolean;
+export interface ExtendedSignalMethodInfo {
+    className: string;
+    signalName: string;
+    methodName: string;
+    handler: (...args: unknown[]) => unknown | Promise<unknown>;
+    instance: Record<string, unknown>;
+}
+export interface ExtendedQueryMethodInfo {
+    className: string;
+    queryName: string;
+    methodName: string;
+    handler: (...args: unknown[]) => unknown | Promise<unknown>;
+    instance: Record<string, unknown>;
+    options?: Record<string, string | number | boolean | object>;
+}
+export interface ChildWorkflowInfo {
+    className: string;
+    propertyKey: string | symbol;
+    workflowType: Type<unknown>;
+    options?: Record<string, string | number | boolean | object>;
+    instance: Record<string, unknown>;
+}
+export type ActivityFunction = (...args: unknown[]) => unknown | Promise<unknown>;
+export interface ActivityMethodInfo {
+    methodName: string;
+    name: string;
+    metadata: ActivityMethodOptions;
+}
+export interface ActivityContext {
+    activityType: string;
+    className?: string;
+    methodName?: string;
+    executionId?: string;
+    timestamp?: Date;
+}
+export interface ScheduleSpec {
+    intervals?: Array<{
+        every: string | number;
+    }>;
+    cronExpressions?: string[];
+    timezones?: string[];
+    startAt?: Date;
+    endAt?: Date;
+    jitter?: string | number;
+}
+export interface ScheduleAction {
+    type: 'startWorkflow';
+    workflowType: string;
+    args?: unknown[];
+    taskQueue: string;
+    workflowId?: string;
 }
-export interface ScheduleInfo {
+export interface ScheduleCreateOptions {
     scheduleId: string;
-    workflowName: string;
-    cronExpression?: string;
-    intervalExpression?: string;
+    spec: ScheduleSpec;
+    action: ScheduleAction;
+    memo?: Record<string, string | number | boolean | object>;
+    searchAttributes?: Record<string, string | number | boolean | object>;
+    workflowType?: string;
+    args?: unknown[];
+    taskQueue?: string;
+    interval?: string | number;
+    cron?: string;
+    timezone?: string;
+    overlapPolicy?: 'skip' | 'buffer_one' | 'buffer_all' | 'cancel_other' | 'terminate_other' | 'allow_all';
+    catchupWindow?: string | number;
+    pauseOnFailure?: boolean;
     description?: string;
-    timezone: string;
-    overlapPolicy: 'ALLOW_ALL' | 'SKIP' | 'BUFFER_ONE' | 'BUFFER_ALL' | 'CANCEL_OTHER';
-    isActive: boolean;
-    autoStart: boolean;
+    paused?: boolean;
+    limitedActions?: number;
+}
+export interface WorkflowStartOptions {
+    workflowId?: string;
     taskQueue?: string;
-    handler: (...args: unknown[]) => unknown | Promise<unknown>;
-    controllerInfo: {
-        name: string;
-        instance: object;
+    searchAttributes?: TypedSearchAttributes;
+    memo?: Record<string, string | number | boolean | object>;
+    workflowIdReusePolicy?: 'ALLOW_DUPLICATE' | 'ALLOW_DUPLICATE_FAILED_ONLY' | 'REJECT_DUPLICATE';
+    workflowExecutionTimeout?: string;
+    workflowRunTimeout?: string;
+    workflowTaskTimeout?: string;
+}
+export type HealthStatus = 'healthy' | 'unhealthy' | 'degraded';
+export interface ServiceHealth {
+    status: HealthStatus;
+    details?: Record<string, string | number | boolean | object>;
+    timestamp?: Date;
+}
+export interface ServiceStats {
+    activities: {
+        classes: number;
+        methods: number;
+        total: number;
+    };
+    schedules: number;
+    discoveries: DiscoveryStats;
+    worker: WorkerStatus;
+    client: ServiceHealth;
+}
+export type OverlapPolicy = 'skip' | 'buffer_one' | 'buffer_all' | 'cancel_other' | 'terminate_other' | 'allow_all';
+export type TemporalOverlapPolicy = 'SKIP' | 'BUFFER_ONE' | 'BUFFER_ALL' | 'CANCEL_OTHER' | 'TERMINATE_OTHER' | 'ALLOW_ALL';
+export interface MetadataInfo {
+    [key: string]: string | number | boolean | object | null;
+}
+export type ActivityWrapper = (...args: unknown[]) => Promise<unknown>;
+export interface ProviderInstance {
+    [key: string]: string | number | boolean | object | null | undefined;
+}
+export interface NestJSWrapper {
+    instance?: Record<string, unknown>;
+    metatype?: new (...args: unknown[]) => Record<string, unknown>;
+}
+export interface InstanceWithConstructor {
+    constructor: new (...args: unknown[]) => Record<string, unknown>;
+}
+export interface DiscoveredActivity {
+    name: string;
+    className: string;
+    method: ActivityMethodInfo | ActivityMethodHandler;
+    instance: Record<string, unknown>;
+    handler: ActivityMethodHandler;
+}
+export interface WorkflowSignalConfig {
+    name: string;
+    args?: unknown[];
+}
+export type WorkflowHandleWithMetadata = import('@temporalio/client').WorkflowHandle & {
+    handle: import('@temporalio/client').WorkflowHandle;
+};
+export interface ClientServiceStatus {
+    available: boolean;
+    healthy: boolean;
+    initialized: boolean;
+    lastHealthCheck: Date | null;
+    namespace: string;
+}
+export interface ClientHealthStatus {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+}
+export interface GenericClient {
+    workflow: {
+        start: (type: string, options: Record<string, string | number | boolean | object>) => Promise<import('@temporalio/client').WorkflowHandle>;
+        getHandle: (id: string, runId?: string) => import('@temporalio/client').WorkflowHandle;
+    };
+}
+export interface ScheduleDescription {
+    spec: ScheduleSpec;
+    action: ScheduleAction;
+    policies: {
+        overlap: TemporalOverlapPolicy;
+        catchupWindow: number;
+        pauseOnFailure: boolean;
+    };
+    state: {
+        paused: boolean;
+        note?: string;
+        remainingActions?: number;
+    };
+}
+export interface DiscoveryServiceStats {
+    methods: number;
+    activities: number;
+    totalComponents: number;
+}
+export interface DiscoveryHealthStatus {
+    isComplete: boolean;
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    discoveredItems?: {
+        activities: number;
     };
-    createdAt: Date;
-    lastTriggered?: Date;
-    lastModified?: Date;
-    nextRun?: Date;
-    triggerCount?: number;
+    lastDiscovery?: Date | null;
+    discoveryDuration?: number | null;
+    totalComponents?: number;
+}
+export interface DiscoveryServiceConfig {
+    enableLogging: boolean;
+    logLevel: LogLevel;
+    activityClasses: Array<Type<unknown>>;
+}
+export interface ComponentDiscoveryResult {
+    success: boolean;
+    discoveredCount: number;
+    errors: Array<{
+        component: string;
+        error: string;
+    }>;
+    duration: number;
+}
+export interface ActivityMethodValidationResult {
+    isValid: boolean;
+    issues: string[];
+    warnings?: string[];
+}
+export interface DiscoveryServiceOptions {
+    enableLogger?: boolean;
+    logLevel?: LogLevel;
+    activityClasses?: Array<Type<unknown>>;
+    validateOnDiscovery?: boolean;
+    cacheResults?: boolean;
+}
+export interface WrapperProcessingResult {
+    success: boolean;
+    processedCount: number;
+    errors: Array<{
+        component: string;
+        error: string;
+    }>;
+}
+export interface ActivityDiscoveryContext {
+    className: string;
+    instance: Record<string, unknown>;
+    metatype: Type<unknown>;
+    validationResult?: ActivityMethodValidationResult;
+}
+export interface ActivityMethodMetadataResult {
+    name: string;
+    originalName: string;
+    methodName: string;
+    className: string;
+    options?: Record<string, unknown>;
+    handler?: Function;
+}
+export interface ActivityMetadataExtractionResult {
+    success: boolean;
+    methods: Map<string, ActivityMethodMetadataResult>;
+    errors: Array<{
+        method: string;
+        error: string;
+    }>;
+    extractedCount: number;
+}
+export interface ActivityClassValidationResult {
+    isValid: boolean;
+    issues: string[];
+    warnings?: string[];
+    className?: string;
+    methodCount?: number;
+}
+export interface MetadataValidationResult {
+    isValid: boolean;
+    missing: string[];
+    present: string[];
+    target: string;
+}
+export interface ActivityInfoResult {
+    className: string;
+    isActivity: boolean;
+    activityName: string | null;
+    methodNames: string[];
+    metadata: unknown;
+    activityOptions: unknown;
+    methodCount: number;
+}
+export interface CacheStatsResult {
+    size: number;
+    entries: string[];
+    message?: string;
+    note?: string;
+    hitRate?: number;
+    missRate?: number;
+}
+export interface SignalMethodExtractionResult {
+    success: boolean;
+    methods: Record<string, string>;
+    errors: Array<{
+        method: string;
+        error: string;
+    }>;
+}
+export interface QueryMethodExtractionResult {
+    success: boolean;
+    methods: Record<string, string>;
+    errors: Array<{
+        method: string;
+        error: string;
+    }>;
+}
+export interface ChildWorkflowExtractionResult {
+    success: boolean;
+    workflows: Record<string, unknown>;
+    errors: Array<{
+        workflow: string;
+        error: string;
+    }>;
+}
+export interface MetadataExtractionOptions {
+    includeOptions?: boolean;
+    validateMethods?: boolean;
+    cacheResults?: boolean;
+    strictMode?: boolean;
+}
+export interface ActivityMethodExtractionContext {
+    instance: unknown;
+    className: string;
+    methodName: string;
+    prototype: object;
+    metadata: unknown;
+}
+export interface ScheduleCreationOptions {
+    scheduleId: string;
+    spec: ScheduleSpec;
+    action: ScheduleAction;
+    memo?: Record<string, unknown>;
+    searchAttributes?: Record<string, unknown>;
+}
+export interface ScheduleCreationResult {
+    success: boolean;
+    scheduleId?: string;
+    handle?: ScheduleHandle;
+    error?: Error;
+}
+export interface ScheduleRetrievalResult {
+    success: boolean;
+    handle?: ScheduleHandle;
+    error?: Error;
+}
+export interface ScheduleServiceStatus {
+    available: boolean;
+    healthy: boolean;
+    schedulesSupported: boolean;
+    initialized: boolean;
+}
+export interface ScheduleServiceHealth {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    schedulesCount: number;
+    isInitialized: boolean;
+    details: Record<string, unknown>;
     lastError?: string;
 }
+export interface ScheduleServiceStats {
+    total: number;
+    active: number;
+    inactive: number;
+    errors: number;
+    lastUpdated?: Date;
+}
+export interface ScheduleDiscoveryResult {
+    success: boolean;
+    discoveredCount: number;
+    errors: Array<{
+        schedule: string;
+        error: string;
+    }>;
+    duration: number;
+}
+export interface ScheduleRegistrationResult {
+    success: boolean;
+    scheduleId: string;
+    handle?: ScheduleHandle;
+    error?: Error;
+}
+export interface ScheduleMetadataValidationResult {
+    isValid: boolean;
+    issues: string[];
+    warnings?: string[];
+    scheduleId?: string;
+}
+export interface ScheduleClientInitResult {
+    success: boolean;
+    client?: ScheduleClient;
+    error?: Error;
+    source: 'existing' | 'new' | 'none';
+}
+export interface ScheduleWorkflowOptions {
+    taskQueue?: string;
+    workflowId?: string;
+    workflowExecutionTimeout?: string;
+    workflowRunTimeout?: string;
+    workflowTaskTimeout?: string;
+    retryPolicy?: Record<string, unknown>;
+    args?: unknown[];
+}
+export interface ScheduleSpecBuilderResult {
+    success: boolean;
+    spec?: Record<string, unknown>;
+    error?: Error;
+}
+export interface ScheduleIntervalParseResult {
+    success: boolean;
+    interval?: Record<string, unknown>;
+    error?: Error;
+}
+export interface TemporalConnection {
+    address: string;
+    namespace?: string;
+    tls?: boolean | object;
+    metadata?: Record<string, string>;
+}
+export interface ScheduleWorkflowAction {
+    type: 'startWorkflow';
+    workflowType: string;
+    taskQueue: string;
+    args?: unknown[];
+    workflowId?: string;
+    workflowExecutionTimeout?: string;
+    workflowRunTimeout?: string;
+    workflowTaskTimeout?: string;
+    retryPolicy?: Record<string, unknown>;
+}
+export interface ScheduleOptions {
+    scheduleId: string;
+    spec: Record<string, unknown>;
+    action: ScheduleWorkflowAction;
+    memo?: Record<string, unknown>;
+    searchAttributes?: Record<string, unknown>;
+}
+export interface WorkerConnectionOptions {
+    address: string;
+    tls?: boolean | object;
+    metadata?: Record<string, string>;
+    apiKey?: string;
+    namespace?: string;
+}
+export interface WorkerConfig {
+    taskQueue: string;
+    namespace: string;
+    connection: NativeConnection;
+    activities: Record<string, Function>;
+    workflowsPath?: string;
+    workflowBundle?: unknown;
+    workerOptions?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface WorkerInitResult {
+    success: boolean;
+    worker?: Worker;
+    error?: Error;
+    activitiesCount: number;
+    taskQueue: string;
+    namespace: string;
+}
+export interface WorkerRestartResult {
+    success: boolean;
+    error?: Error;
+    restartCount: number;
+    maxRestarts: number;
+}
+export interface WorkerShutdownResult {
+    success: boolean;
+    error?: Error;
+    shutdownTime: number;
+}
+export interface WorkerHealthStatus {
+    isHealthy: boolean;
+    isRunning: boolean;
+    isInitialized: boolean;
+    lastError?: string;
+    uptime?: number;
+    activitiesCount: number;
+    restartCount: number;
+    maxRestarts: number;
+}
+export interface WorkerStats {
+    isInitialized: boolean;
+    isRunning: boolean;
+    activitiesCount: number;
+    restartCount: number;
+    maxRestarts: number;
+    uptime?: number;
+    startedAt?: Date;
+    lastError?: string;
+    taskQueue: string;
+    namespace: string;
+    workflowSource: 'bundle' | 'filesystem' | 'registered' | 'none';
+}
+export interface ActivityRegistrationResult {
+    success: boolean;
+    registeredCount: number;
+    errors: Array<{
+        activityName: string;
+        error: string;
+    }>;
+}
+export interface WorkerDiscoveryResult {
+    success: boolean;
+    discoveredActivities: number;
+    loadedActivities: number;
+    errors: Array<{
+        component: string;
+        error: string;
+    }>;
+    duration: number;
+}
+export interface TemporalServiceInitResult {
+    success: boolean;
+    error?: Error;
+    servicesInitialized: {
+        client: boolean;
+        worker: boolean;
+        schedule: boolean;
+        discovery: boolean;
+        metadata: boolean;
+    };
+    initializationTime: number;
+}
+export interface WorkflowExecutionResult<T = unknown> {
+    success: boolean;
+    result?: T;
+    error?: Error;
+    workflowId?: string;
+    runId?: string;
+    executionTime?: number;
+}
+export interface WorkflowSignalResult {
+    success: boolean;
+    error?: Error;
+    workflowId: string;
+    signalName: string;
+}
+export interface WorkflowQueryResult<T = unknown> {
+    success: boolean;
+    result?: T;
+    error?: Error;
+    workflowId: string;
+    queryName: string;
+}
+export interface WorkflowTerminationResult {
+    success: boolean;
+    error?: Error;
+    workflowId: string;
+    reason?: string;
+}
+export interface WorkflowCancellationResult {
+    success: boolean;
+    error?: Error;
+    workflowId: string;
+}
+export interface ActivityExecutionResult<T = unknown> {
+    success: boolean;
+    result?: T;
+    error?: Error;
+    activityName: string;
+    executionTime?: number;
+    args?: unknown[];
+}
+export interface ServiceHealthStatus {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    isInitialized: boolean;
+    lastError?: string;
+    uptime?: number;
+    details?: Record<string, unknown>;
+}
+export interface ComponentHealthStatus {
+    client: ServiceHealthStatus;
+    worker: ServiceHealthStatus;
+    schedule: ServiceHealthStatus;
+    activity: ServiceHealthStatus;
+    discovery: ServiceHealthStatus;
+}
+export interface OverallHealthStatus {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    components: ComponentHealthStatus;
+    isInitialized: boolean;
+    namespace: string;
+    summary: {
+        totalActivities: number;
+        totalSchedules: number;
+        workerRunning: boolean;
+        clientConnected: boolean;
+    };
+    timestamp: Date;
+}
+export interface ServiceStatistics {
+    activities: {
+        classes: number;
+        methods: number;
+        total: number;
+        registered: number;
+        available: number;
+    };
+    schedules: {
+        total: number;
+        active: number;
+        paused: number;
+    };
+    worker: {
+        isRunning: boolean;
+        isHealthy: boolean;
+        activitiesCount: number;
+        uptime?: number;
+    };
+    client: {
+        isConnected: boolean;
+        isHealthy: boolean;
+        namespace: string;
+    };
+    discovery: {
+        isComplete: boolean;
+        discoveredCount: number;
+        errors: number;
+    };
+}
+export interface ServiceInitOptions {
+    waitForServices?: boolean;
+    maxWaitTime?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+export interface ServiceShutdownOptions {
+    graceful?: boolean;
+    timeout?: number;
+    stopWorker?: boolean;
+}
+export interface ServiceShutdownResult {
+    success: boolean;
+    error?: Error;
+    shutdownTime: number;
+    servicesShutdown: {
+        worker: boolean;
+        client: boolean;
+        schedule: boolean;
+    };
+}
+export interface HealthResponse {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    timestamp: string;
+    uptime: number;
+    client: {
+        available: boolean;
+        healthy: boolean;
+        connected: boolean;
+    };
+    worker: {
+        available: boolean;
+        running: boolean;
+        healthy: boolean;
+        activitiesCount: number;
+    };
+    discovery: {
+        activities: number;
+        complete: boolean;
+        discoveredCount: number;
+    };
+    schedules: {
+        total: number;
+        active: number;
+        paused: number;
+    };
+    metadata: {
+        classes: number;
+        methods: number;
+        total: number;
+    };
+    summary: {
+        totalComponents: number;
+        healthyComponents: number;
+        degradedComponents: number;
+        unhealthyComponents: number;
+    };
+}