@ductape/sdk 0.1.25 → 0.1.27

package/dist/features/types/features.types.d.ts

@@ -0,0 +1,1081 @@
+/**
+ * Feature Service Types
+ *
+ * Type definitions for the Ductape Features code-first API.
+ */
+import { IProductFeature, IProductFeatureStep, IFeatureOptions, IFeatureSignal, IFeatureQuery, IFeatureEnv, IFeatureStepOptions, IFeatureStepRollback, FeatureStepType, FeatureRollbackStrategy, FeatureStatus, IActionRequest, INotificationRequest, IDbActionRequest, IStorageRequest } from '../../types';
+/**
+ * Configuration options for FeatureService initialization
+ */
+export interface IFeatureServiceConfig {
+    /** Workspace ID */
+    workspace_id: string;
+    /** Public key for authentication */
+    public_key: string;
+    /** User ID */
+    user_id: string;
+    /** Authentication token */
+    token: string;
+    /** Environment type (staging, production, local) */
+    env_type: string;
+    /** Optional Redis client for caching */
+    redis_client?: any;
+}
+/**
+ * Feature configuration for local registration
+ */
+export interface IFeatureConfig {
+    /** Human-readable name */
+    name: string;
+    /** Unique feature tag */
+    tag: string;
+    /** Description */
+    description?: string;
+    /** Input schema */
+    input?: Record<string, unknown>;
+    /** Output schema */
+    output?: Record<string, unknown>;
+    /** Feature steps */
+    steps: IProductFeatureStep[];
+    /** Signal definitions */
+    signals?: Record<string, IFeatureSignal>;
+    /** Query definitions */
+    queries?: Record<string, IFeatureQuery>;
+    /** Feature options */
+    options?: IFeatureOptions;
+    /** Environment configurations */
+    envs?: IFeatureEnv[];
+}
+/**
+ * Additional context metadata for feature execution
+ */
+export interface IFeatureContextMeta {
+    /** Request ID */
+    request_id?: string;
+    /** Correlation ID */
+    correlation_id?: string;
+    /** Parent feature ID (for child features) */
+    parent_feature_id?: string;
+    /** Parent step tag (for child features) */
+    parent_step_tag?: string;
+    /** Custom metadata */
+    [key: string]: unknown;
+}
+/**
+ * Logger interface for feature execution
+ */
+export interface IFeatureLogger {
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+}
+/**
+ * Wait options for signals
+ */
+export interface IWaitOptions {
+    /** Timeout duration (ms or duration string like '1h', '30m') */
+    timeout?: number | string;
+}
+/**
+ * Child feature options
+ */
+export interface IChildFeatureOptions {
+    /** Timeout for child feature */
+    timeout?: number | string;
+    /** Number of retries */
+    retries?: number;
+    /** How to handle parent cancellation */
+    parent_close_policy?: 'terminate' | 'abandon' | 'request_cancel';
+    /** Idempotency key */
+    idempotency_key?: string;
+}
+/**
+ * Rollback result
+ */
+export interface IRollbackResult {
+    /** Whether rollback was successful */
+    success: boolean;
+    /** Steps that were rolled back */
+    rolled_back_steps: string[];
+    /** Steps that failed to rollback */
+    failed_steps?: Array<{
+        tag: string;
+        error: string;
+    }>;
+    /** Reason for triggering rollback */
+    reason: string;
+}
+/**
+ * Action context for feature steps
+ */
+export interface IFeatureActionContext {
+    run<T>(options: {
+        app: string;
+        event: string;
+        input: IActionRequest;
+        retries?: number;
+        timeout?: number;
+    }): Promise<T>;
+}
+/**
+ * Database context for feature steps
+ */
+export interface IFeatureDatabaseContext {
+    execute<T>(options: {
+        database: string;
+        event: string;
+        input: IDbActionRequest;
+        retries?: number;
+        timeout?: number;
+    }): Promise<T>;
+    query<T>(options: {
+        database: string;
+        event: string;
+        params?: Record<string, unknown>;
+    }): Promise<T[]>;
+    insert<T>(options: {
+        database: string;
+        event: string;
+        data: Record<string, unknown>;
+    }): Promise<T>;
+    update<T>(options: {
+        database: string;
+        event: string;
+        data: Record<string, unknown>;
+        where: Record<string, unknown>;
+    }): Promise<T>;
+    delete(options: {
+        database: string;
+        event: string;
+        where: Record<string, unknown>;
+    }): Promise<boolean>;
+}
+/**
+ * Graph context for feature steps
+ */
+export interface IFeatureGraphContext {
+    execute<T>(options: {
+        graph: string;
+        action: string;
+        input: Record<string, unknown>;
+    }): Promise<T>;
+    createNode<T>(options: {
+        graph: string;
+        labels: string[];
+        properties: Record<string, unknown>;
+    }): Promise<T>;
+    updateNode<T>(options: {
+        graph: string;
+        id: string | number;
+        properties: Record<string, unknown>;
+    }): Promise<T>;
+    deleteNode(options: {
+        graph: string;
+        id: string | number;
+    }): Promise<void>;
+    createRelationship<T>(options: {
+        graph: string;
+        from: string;
+        to: string;
+        type: string;
+        properties?: Record<string, unknown>;
+    }): Promise<T>;
+    deleteRelationship(options: {
+        graph: string;
+        id: string | number;
+    }): Promise<void>;
+    query<T>(options: {
+        graph: string;
+        action: string;
+        params?: Record<string, unknown>;
+    }): Promise<T[]>;
+}
+/**
+ * Notification context for feature steps
+ */
+export interface IFeatureNotificationContext {
+    send(options: {
+        notification: string;
+        event: string;
+        input: INotificationRequest;
+        retries?: number;
+    }): Promise<void>;
+    email(options: {
+        notification: string;
+        event: string;
+        recipients: string[];
+        subject: Record<string, unknown>;
+        template: Record<string, unknown>;
+    }): Promise<void>;
+    push(options: {
+        notification: string;
+        event: string;
+        tokens: string[];
+        title: Record<string, unknown>;
+        body: Record<string, unknown>;
+        data?: Record<string, unknown>;
+    }): Promise<void>;
+    sms(options: {
+        notification: string;
+        event: string;
+        phones: string[];
+        message: Record<string, unknown>;
+    }): Promise<void>;
+}
+/**
+ * Storage context for feature steps
+ */
+export interface IFeatureStorageContext {
+    upload(options: {
+        storage: string;
+        event: string;
+        input: IStorageRequest;
+        retries?: number;
+    }): Promise<IFileUploadResult>;
+    download(options: {
+        storage: string;
+        event: string;
+        input: IStorageRequest;
+    }): Promise<IFileDownloadResult>;
+    delete(options: {
+        storage: string;
+        event: string;
+        input: {
+            file_key: string;
+        };
+    }): Promise<void>;
+}
+/**
+ * Messaging context for feature steps (Ductape primitive).
+ * Use ctx.messaging.produce() to publish to a message broker.
+ */
+export interface IFeatureMessagingContext {
+    /**
+     * Publish a message to a broker topic.
+     * @param options.event - Full event string "broker-tag:topic-tag" (e.g. "order-events:payment-processed")
+     * @param options.message - Message payload
+     */
+    produce(options: {
+        event: string;
+        message: Record<string, unknown>;
+    }): Promise<void>;
+}
+/**
+ * Publish context for feature steps.
+ * @deprecated Prefer ctx.messaging.produce() (Ductape primitive).
+ */
+export interface IFeaturePublishContext {
+    send(options: {
+        broker: string;
+        event: string;
+        input: {
+            message: Record<string, unknown>;
+        };
+        retries?: number;
+    }): Promise<void>;
+}
+/**
+ * Quota context for feature steps
+ */
+export interface IFeatureQuotaContext {
+    execute<T>(options: {
+        quota: string;
+        input: Record<string, unknown>;
+        timeout?: number;
+    }): Promise<T>;
+}
+/**
+ * Fallback context for feature steps
+ */
+export interface IFeatureFallbackContext {
+    execute<T>(options: {
+        fallback: string;
+        input: Record<string, unknown>;
+        timeout?: number;
+    }): Promise<T>;
+}
+/**
+ * Healthcheck context for feature steps
+ */
+export interface IFeatureHealthcheckContext {
+    getStatus(tag: string): Promise<{
+        status: 'available' | 'unavailable';
+        lastChecked?: string;
+        lastLatency?: number;
+    }>;
+}
+/**
+ * Transform context for data transformations
+ */
+export interface ITransformContext {
+    /** Get the number of keys in an object */
+    size(obj: Record<string, unknown>): number;
+    /** Get the length of an array or string */
+    length(arr: unknown[] | string): number;
+    /** Parse JSON string */
+    parseJson<T>(str: string): T;
+    /** Stringify to JSON */
+    stringify(obj: unknown): string;
+    /** Convert to uppercase */
+    upper(str: string): string;
+    /** Convert to lowercase */
+    lower(str: string): string;
+    /** Trim whitespace */
+    trim(str: string): string;
+    /** Split string */
+    split(str: string, separator: string): string[];
+    /** Join array */
+    join(arr: string[], separator: string): string;
+    /** Get current timestamp */
+    now(): number;
+    /** Format date */
+    formatDate(date: Date | number | string, format: string): string;
+}
+/**
+ * File upload result
+ */
+export interface IFileUploadResult {
+    file_key: string;
+    url?: string;
+    size?: number;
+    content_type?: string;
+}
+/**
+ * File download result
+ */
+export interface IFileDownloadResult {
+    content: Buffer | string;
+    content_type?: string;
+    size?: number;
+}
+/**
+ * Full feature context interface
+ */
+export interface IFeatureContext<TInput = Record<string, unknown>> {
+    /** Feature input (read-only) */
+    readonly input: TInput;
+    /** Feature metadata */
+    readonly feature_id: string;
+    readonly feature_tag: string;
+    readonly env: string;
+    readonly product: string;
+    readonly context: IFeatureContextMeta;
+    /** Execution state */
+    readonly state: Record<string, unknown>;
+    readonly steps: Record<string, unknown>;
+    readonly completed_steps: string[];
+    readonly current_step: string | null;
+    /** Session token in format: session_tag:jwt_token */
+    readonly session?: string;
+    /** Step execution */
+    step<T>(tag: string, handler: () => Promise<T>, rollback?: ((result: T) => Promise<void>) | null, options?: IFeatureStepOptions): Promise<T>;
+    /** Ductape components */
+    action: IFeatureActionContext;
+    database: IFeatureDatabaseContext;
+    graph: IFeatureGraphContext;
+    notification: IFeatureNotificationContext;
+    storage: IFeatureStorageContext;
+    /** Message broker (Ductape primitive). Prefer over publish. */
+    events: IFeatureMessagingContext;
+    /** @deprecated Prefer ctx.events.produce() */
+    publish: IFeaturePublishContext;
+    /** Resilience components */
+    quota: IFeatureQuotaContext;
+    fallback: IFeatureFallbackContext;
+    healthcheck: IFeatureHealthcheckContext;
+    /** Data transformations */
+    transform: ITransformContext;
+    /** Data references */
+    variable(app: string, key: string): unknown;
+    constant(app: string, key: string): unknown;
+    token(key: string): string;
+    auth: Record<string, unknown>;
+    default<T>(value: T | undefined, fallback: T): T;
+    /** Control flow */
+    sleep(duration: number | string): Promise<void>;
+    waitForSignal<T>(signal: string | string[], options?: IWaitOptions): Promise<T>;
+    checkpoint(name: string, metadata?: Record<string, unknown>): Promise<void>;
+    /** State management */
+    setState(key: string, value: unknown): void;
+    getState<T>(key: string): T | undefined;
+    /** Logging */
+    log: IFeatureLogger;
+    /** Child features */
+    feature<TChildInput, TChildOutput>(childId: string, tag: string, input: TChildInput, options?: IChildFeatureOptions): Promise<TChildOutput>;
+    /** Rollback control */
+    triggerRollback(reason: string): Promise<IRollbackResult>;
+}
+/**
+ * Feature handler function type
+ */
+export type FeatureHandler<TInput = Record<string, unknown>, TOutput = unknown> = (ctx: IFeatureContext<TInput>) => Promise<TOutput>;
+/**
+ * Options for defining a feature with code-first API
+ */
+export interface IDefineFeatureOptions<TInput = Record<string, unknown>, TOutput = unknown> {
+    /** Target product (optional if using builder pattern) */
+    product?: string;
+    /** Unique feature tag */
+    tag: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Input schema (field names and types for documentation/validation), e.g. { orderId: { type: 'string', required: true } } */
+    input?: Record<string, {
+        type: string;
+        required?: boolean;
+    }>;
+    /** Output schema (optional, for documentation) */
+    output?: Record<string, unknown>;
+    /** Signal definitions */
+    signals?: Record<string, {
+        input?: Record<string, string>;
+    }>;
+    /** Query definitions */
+    queries?: Record<string, {
+        handler?: (ctx: IFeatureContext<TInput>) => unknown;
+    }>;
+    /** Feature options */
+    options?: IFeatureOptions;
+    /** Environment configurations */
+    envs?: IFeatureEnv[];
+    /**
+     * Optional step result overrides when recording the handler.
+     * Use when the handler branches on a step result (e.g. if (!validation.valid) return ...).
+     * Key = step tag, value = result to return to the handler so it continues and records later steps.
+     * Example: { validate: { valid: true } } so the handler does not early-return and process-payment is recorded.
+     * Steps recorded after an overridden step get a condition so they only run when that step's real output matches (e.g. $Step{validate}{valid} == true).
+     */
+    branchOverrides?: Record<string, unknown>;
+    /**
+     * Sample input used during recording so loops and control flow see real values.
+     * Example: { items: [{ id: '1' }, { id: '2' }] } so that for (const item of ctx.input.items) runs twice and records steps process-1, process-2.
+     * Use unique step tags per iteration (e.g. ctx.step(`process-${item.id}`, ...)).
+     */
+    recordInput?: TInput;
+    /**
+     * For switch/alternate branches: run the handler once per scenario with that as recordInput.
+     * Each step recorded in that run gets a condition so it only runs when feature input matches (e.g. $Input{type} == 'a').
+     * Example: recordScenarios: [ { type: 'a' }, { type: 'b' } ] records both branches; handle-a gets condition $Input{type} == 'a', handle-b gets $Input{type} == 'b'.
+     */
+    recordScenarios?: Record<string, unknown>[];
+    /** Feature handler function */
+    handler: FeatureHandler<TInput, TOutput>;
+}
+/**
+ * Options for executing a feature
+ */
+export interface IExecuteFeatureOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature tag */
+    tag: string;
+    /** Feature input */
+    input: Record<string, unknown>;
+    /** Pre-resolved product ID (avoids duplicate initProduct when provided) */
+    product_id?: string;
+    /** Session token in format: session_tag:jwt_token */
+    session?: string;
+    /** Idempotency key */
+    idempotency_key?: string;
+    /** Cache tag */
+    cache?: string;
+    /** Number of retries */
+    retries?: number;
+    /** Timeout in ms */
+    timeout?: number;
+}
+/**
+ * Feature execution result
+ */
+export interface IFeatureExecutionResult<T = unknown> {
+    /** Execution status */
+    status: FeatureStatus;
+    /** Feature ID */
+    feature_id: string;
+    /** Output data */
+    output?: T;
+    /** Error message if failed */
+    error?: string;
+    /** Execution time in ms */
+    execution_time: number;
+    /** Completed steps */
+    completed_steps: string[];
+    /** Per-step timing (tag, duration_ms, success) for reporting */
+    step_timings?: Array<{
+        tag: string;
+        duration_ms: number;
+        success: boolean;
+    }>;
+    /** Failed step (if any) */
+    failed_step?: string;
+    /** Rollback info (if rolled back) */
+    rollback_info?: {
+        triggered_by: string;
+        reason: string;
+        rolled_back_steps: string[];
+        failed_rollbacks?: Array<{
+            tag: string;
+            error: string;
+        }>;
+    };
+}
+/**
+ * Schedule configuration for dispatched features
+ */
+export interface IFeatureSchedule {
+    /** Start time (timestamp or ISO string) */
+    start_at?: number | string;
+    /** Cron expression for recurring */
+    cron?: string;
+    /** Interval in ms for recurring */
+    every?: number;
+    /** Maximum number of executions */
+    limit?: number;
+    /** End date for recurring */
+    endDate?: number | string;
+    /** Timezone */
+    tz?: string;
+}
+/**
+ * Options for dispatching a feature
+ */
+export interface IFeatureDispatchInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature tag */
+    feature: string;
+    /** Feature input */
+    input: Record<string, unknown>;
+    /** Schedule configuration */
+    schedule?: IFeatureSchedule;
+    /** Session token in format: session_tag:jwt_token */
+    session?: string;
+    /** Cache tag */
+    cache?: string;
+    /** Number of retries */
+    retries?: number;
+}
+/**
+ * Dispatch result
+ */
+export interface IFeatureDispatchResult {
+    /** Job ID */
+    job_id: string;
+    /** Job status */
+    status: 'scheduled' | 'queued' | 'running';
+    /** Scheduled timestamp */
+    scheduled_at?: number;
+    /** Whether this is a recurring job */
+    recurring?: boolean;
+    /** Next run timestamp (for recurring) */
+    next_run_at?: number;
+}
+/**
+ * Options for sending a signal to a feature
+ */
+export interface ISendSignalOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature ID */
+    feature_id: string;
+    /** Signal name */
+    signal: string;
+    /** Signal payload */
+    payload?: Record<string, unknown>;
+}
+/**
+ * Options for querying a feature
+ */
+export interface IQueryFeatureOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature ID */
+    feature_id: string;
+    /** Query name */
+    query: string;
+    /** Query parameters */
+    params?: Record<string, unknown>;
+}
+/**
+ * Step builder interface for fluent API
+ */
+export interface IStepBuilder {
+    /** Set as action step */
+    action(app: string, event: string): IStepBuilder;
+    /** Set as database step */
+    database(database: string, event: string): IStepBuilder;
+    /** Set as graph step */
+    graph(graph: string, action: string): IStepBuilder;
+    /** Set as notification step */
+    notification(notification: string, event: string): IStepBuilder;
+    /** Set as storage step */
+    storage(storage: string, event: string): IStepBuilder;
+    /** Set as message broker produce step */
+    produce(broker: string, event: string): IStepBuilder;
+    /** @deprecated Use produce() */
+    publish(broker: string, event: string): IStepBuilder;
+    /** Set as quota step */
+    quota(quota: string): IStepBuilder;
+    /** Set as fallback step */
+    fallback(fallback: string): IStepBuilder;
+    /** Set as child feature step */
+    feature(feature: string): IStepBuilder;
+    /** Set as sleep step */
+    sleep(duration: number | string): IStepBuilder;
+    /** Set as wait for signal step */
+    waitForSignal(signal: string, timeout?: number | string): IStepBuilder;
+    /** Set as checkpoint step */
+    checkpoint(): IStepBuilder;
+    /** Set step input */
+    input(input: Record<string, unknown>): IStepBuilder;
+    /** Set step dependencies */
+    dependsOn(steps: string[]): IStepBuilder;
+    /** Set step condition */
+    condition(condition: string): IStepBuilder;
+    /** Set step options */
+    options(options: IFeatureStepOptions): IStepBuilder;
+    /** Mark as optional */
+    optional(): IStepBuilder;
+    /** Mark as critical */
+    critical(): IStepBuilder;
+    /** Mark as allow_fail */
+    allowFail(): IStepBuilder;
+    /** Set step name */
+    name(name: string): IStepBuilder;
+    /** Configure rollback */
+    rollback(): IRollbackBuilder;
+    /** Complete step definition and return to feature builder */
+    done(): IFeatureBuilder;
+}
+/**
+ * Rollback builder interface for fluent API
+ */
+export interface IRollbackBuilder {
+    /** Set as action rollback */
+    action(app: string, event: string): IRollbackBuilder;
+    /** Set as database rollback */
+    database(database: string, event: string): IRollbackBuilder;
+    /** Set as graph rollback */
+    graph(graph: string, action: string): IRollbackBuilder;
+    /** Set as notification rollback */
+    notification(notification: string, event: string): IRollbackBuilder;
+    /** Set as storage rollback */
+    storage(storage: string, event: string): IRollbackBuilder;
+    /** Set as message broker produce rollback */
+    produce(broker: string, event: string): IRollbackBuilder;
+    /** @deprecated Use produce() */
+    publish(broker: string, event: string): IRollbackBuilder;
+    /** Set rollback input */
+    input(input: Record<string, unknown>): IRollbackBuilder;
+    /** Complete rollback definition and return to step builder */
+    done(): IStepBuilder;
+}
+/**
+ * Feature builder interface for fluent API
+ */
+export interface IFeatureBuilder {
+    /** Set feature name */
+    name(name: string): IFeatureBuilder;
+    /** Set feature description */
+    description(description: string): IFeatureBuilder;
+    /** Set input schema */
+    input(input: Record<string, unknown>): IFeatureBuilder;
+    /** Set output schema */
+    output(output: Record<string, unknown>): IFeatureBuilder;
+    /** Set feature options */
+    options(options: IFeatureOptions): IFeatureBuilder;
+    /** Add environment */
+    env(slug: string, active?: boolean): IFeatureBuilder;
+    /** Add signal */
+    signal(name: string, input?: Record<string, string>): IFeatureBuilder;
+    /** Add query */
+    query(name: string, handler?: string): IFeatureBuilder;
+    /** Start defining a step */
+    step(tag: string): IStepBuilder;
+    /** Build the feature schema */
+    build(): IProductFeature;
+    /** Get compiled JSON schema */
+    toSchema(): IProductFeature;
+}
+/**
+ * Options for replaying a feature
+ */
+export interface IFeatureReplayInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Original feature ID to replay */
+    feature_id: string;
+    /** Override options for the replay */
+    options?: Partial<IFeatureOptions>;
+    /** Reason for replay (for audit) */
+    reason?: string;
+    /** Idempotency key */
+    idempotency_key?: string;
+}
+/**
+ * Result of replaying a feature
+ */
+export interface IFeatureReplayResult extends IFeatureExecutionResult {
+    /** Original feature ID that was replayed */
+    replayed_from: string;
+}
+/**
+ * Options for restarting a feature
+ */
+export interface IFeatureRestartInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Original feature ID to restart */
+    feature_id: string;
+    /** New input (replaces original) */
+    input?: Record<string, unknown>;
+    /** Partial input override (merged with original) */
+    input_override?: Record<string, unknown>;
+    /** Whether to merge input_override with original input */
+    merge_input?: boolean;
+    /** Reason for restart (for audit) */
+    reason?: string;
+    /** Override options */
+    options?: Partial<IFeatureOptions>;
+}
+/**
+ * Result of restarting a feature
+ */
+export interface IFeatureRestartResult extends IFeatureExecutionResult {
+    /** Original feature ID that was restarted */
+    restarted_from: string;
+}
+/**
+ * Options for resuming a feature
+ */
+export interface IFeatureResumeInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature ID to resume */
+    feature_id: string;
+    /** Resume from specific checkpoint */
+    from_checkpoint?: string;
+    /** Resume from specific step */
+    from_step?: string;
+    /** Steps to skip */
+    skip_steps?: string[];
+    /** Additional input for remaining steps */
+    input?: Record<string, unknown>;
+}
+/**
+ * Result of resuming a feature
+ */
+export interface IFeatureResumeResult extends IFeatureExecutionResult {
+    /** Original feature ID that was resumed */
+    resumed_from: string;
+    /** Checkpoint resumed from (if applicable) */
+    resumed_checkpoint?: string;
+}
+/**
+ * Options for replaying from a specific step
+ */
+export interface IFeatureReplayFromStepInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Original feature ID */
+    feature_id: string;
+    /** Step to start from */
+    from_step: string;
+    /** Override outputs from previous steps */
+    step_outputs?: Record<string, unknown>;
+    /** Debug options */
+    debug?: {
+        enabled: boolean;
+        pause_after_step?: boolean;
+        log_level?: 'info' | 'verbose' | 'debug';
+    };
+}
+/**
+ * Options for getting feature status
+ */
+export interface IFeatureStatusInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature ID */
+    feature_id: string;
+}
+/**
+ * Feature status response
+ */
+export interface IFeatureStatus {
+    /** Feature ID */
+    feature_id: string;
+    /** Feature tag */
+    feature_tag: string;
+    /** Current status */
+    status: FeatureStatus;
+    /** Currently executing step */
+    current_step?: string;
+    /** Completed step tags */
+    completed_steps: string[];
+    /** Feature state */
+    state: Record<string, unknown>;
+    /** Start timestamp */
+    started_at: number;
+    /** Last update timestamp */
+    updated_at: number;
+    /** Input data */
+    input?: Record<string, unknown>;
+    /** Output data (if completed) */
+    output?: unknown;
+    /** Error (if failed) */
+    error?: {
+        message: string;
+        step?: string;
+        code?: string;
+    };
+}
+/**
+ * Options for cancelling a feature
+ */
+export interface IFeatureCancelInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature ID */
+    feature_id: string;
+    /** Reason for cancellation */
+    reason?: string;
+}
+/**
+ * Cancel result
+ */
+export interface IFeatureCancelResult {
+    /** Whether cancellation was successful */
+    cancelled: boolean;
+    /** Steps that were rolled back */
+    rolled_back_steps: string[];
+    /** Steps that failed to rollback */
+    failed_rollbacks?: Array<{
+        tag: string;
+        error: string;
+    }>;
+}
+/**
+ * Options for getting feature history
+ */
+export interface IFeatureHistoryInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature ID */
+    feature_id: string;
+    /** Include detailed step information */
+    include_step_details?: boolean;
+    /** Include rollback details */
+    include_rollback_details?: boolean;
+}
+/**
+ * Feature event types
+ */
+export type FeatureEventType = 'feature_started' | 'feature_completed' | 'feature_failed' | 'feature_cancelled' | 'feature_rolled_back' | 'step_started' | 'step_completed' | 'step_failed' | 'step_skipped' | 'step_rolled_back' | 'checkpoint_created' | 'signal_received' | 'signal_timeout' | 'rollback_started' | 'rollback_completed' | 'rollback_failed';
+/**
+ * Feature event
+ */
+export interface IFeatureEvent {
+    /** Event type */
+    type: FeatureEventType;
+    /** Timestamp */
+    timestamp: number;
+    /** Event data */
+    data: Record<string, unknown>;
+}
+/**
+ * Checkpoint info
+ */
+export interface ICheckpoint {
+    /** Checkpoint name */
+    name: string;
+    /** Checkpoint metadata */
+    metadata?: Record<string, unknown>;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Feature history
+ */
+export interface IFeatureHistory {
+    /** Feature ID */
+    feature_id: string;
+    /** Feature tag */
+    feature_tag: string;
+    /** Final status */
+    status: FeatureStatus;
+    /** All events */
+    events: IFeatureEvent[];
+    /** Checkpoints */
+    checkpoints: ICheckpoint[];
+    /** Replay IDs (if this feature was replayed) */
+    replays?: string[];
+    /** Restart IDs (if this feature was restarted) */
+    restarts?: string[];
+}
+/**
+ * Options for getting step details
+ */
+export interface IStepDetailInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature ID */
+    feature_id: string;
+    /** Step tag */
+    step_tag: string;
+}
+/**
+ * Step status
+ */
+export type StepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped' | 'rolled_back';
+/**
+ * Rollback status
+ */
+export type RollbackStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+/**
+ * Step error
+ */
+export interface IStepError {
+    /** Error message */
+    message: string;
+    /** Error code */
+    code?: string;
+    /** Stack trace */
+    stack?: string;
+}
+/**
+ * Step detail
+ */
+export interface IStepDetail {
+    /** Step tag */
+    tag: string;
+    /** Step name */
+    name?: string;
+    /** Step status */
+    status: StepStatus;
+    /** Step input */
+    input?: Record<string, unknown>;
+    /** Step output */
+    output?: Record<string, unknown>;
+    /** Step error (if failed) */
+    error?: IStepError;
+    /** Number of attempts */
+    attempts: number;
+    /** Start timestamp */
+    start_time?: number;
+    /** End timestamp */
+    end_time?: number;
+    /** Duration in ms */
+    duration?: number;
+    /** Rollback status */
+    rollback_status?: RollbackStatus;
+    /** Rollback error (if rollback failed) */
+    rollback_error?: string;
+}
+/**
+ * Options for listing related executions
+ */
+export interface IRelatedExecutionsInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature ID */
+    feature_id: string;
+}
+/**
+ * Related execution entry
+ */
+export interface IRelatedExecution {
+    /** Feature ID */
+    feature_id: string;
+    /** Execution type */
+    type: 'original' | 'replay' | 'restart' | 'resume';
+    /** Status */
+    status: FeatureStatus;
+    /** Created timestamp */
+    created_at: number;
+    /** Original feature ID (for replays) */
+    replayed_from?: string;
+    /** Original feature ID (for restarts) */
+    restarted_from?: string;
+    /** Original feature ID (for resumes) */
+    resumed_from?: string;
+}
+/**
+ * Related executions response
+ */
+export interface IRelatedExecutions {
+    /** Original feature ID */
+    original: string;
+    /** All related executions */
+    executions: IRelatedExecution[];
+}
+/**
+ * Options for comparing executions
+ */
+export interface ICompareExecutionsInput {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Feature IDs to compare */
+    feature_ids: string[];
+}
+/**
+ * Step diff entry
+ */
+export interface IStepDiff {
+    /** Step tag */
+    step: string;
+    /** Status and output per feature */
+    [feature_id: string]: {
+        status: StepStatus;
+        output?: Record<string, unknown>;
+        error?: string;
+    } | string;
+}
+/**
+ * Execution comparison
+ */
+export interface IExecutionComparison {
+    /** Feature IDs compared */
+    features: string[];
+    /** Input differences */
+    input_diff: Record<string, unknown[]>;
+    /** Step differences */
+    step_diffs: IStepDiff[];
+    /** Outcome differences */
+    outcome_diff: Record<string, {
+        status: FeatureStatus;
+        output?: unknown;
+    }>;
+}
+export { IProductFeature, IProductFeatureStep, IFeatureOptions, IFeatureSignal, IFeatureQuery, IFeatureEnv, IFeatureStepOptions, IFeatureStepRollback, FeatureStepType, FeatureRollbackStrategy, FeatureStatus, };