export type StepFunctionDefinition<TInput, TOutput> = {
    readonly __brand: 'StepFunctionDefinition';
    readonly __input: TInput;
    readonly __output: TOutput;
};
export interface DelayOptions {
    seconds?: number;
    timestamp?: string;
    secondsPath?: string;
    timestampPath?: string;
}
export interface MapOptions {
    readonly maxConcurrency?: number;
    readonly retry?: import('./services/types').RetryPolicy | readonly import('./services/types').RetryPolicy[];
}
export interface ItemReaderConfig {
    readonly Resource: 'arn:aws:states:::s3:getObject';
    readonly ReaderConfig: {
        readonly InputType: 'CSV' | 'JSON' | 'MANIFEST';
        readonly CSVHeaderLocation?: 'FIRST_ROW' | 'GIVEN';
        readonly CSVHeaders?: readonly string[];
        readonly MaxItems?: number;
    };
    readonly Parameters?: Record<string, unknown>;
}
export interface ResultWriterConfig {
    readonly Resource: 'arn:aws:states:::s3:putObject';
    readonly Parameters?: Record<string, unknown>;
}
export interface ItemBatcherConfig {
    readonly MaxItemsPerBatch?: number;
    readonly MaxInputBytesPerBatch?: number;
    readonly BatchInput?: Record<string, unknown>;
}
export interface DistributedMapOptions {
    readonly maxConcurrency?: number;
    readonly executionType?: 'STANDARD' | 'EXPRESS';
    readonly itemReader?: ItemReaderConfig;
    readonly resultWriter?: ResultWriterConfig;
    readonly itemBatcher?: ItemBatcherConfig;
    readonly toleratedFailurePercentage?: number;
    readonly toleratedFailureCount?: number;
    readonly label?: string;
    readonly retry?: import('./services/types').RetryPolicy | readonly import('./services/types').RetryPolicy[];
}
export interface ParallelOptions {
    readonly retry?: import('./services/types').RetryPolicy | readonly import('./services/types').RetryPolicy[];
}
export type HashAlgorithm = 'MD5' | 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
export type SequentialIterable<T> = Iterable<T> & {
    readonly __brand: 'SequentialIterable';
};
export declare class Steps {
    private constructor();
    static createFunction<TInput, TOutput>(_factory: (context: SimpleStepContext, input: TInput) => Promise<TOutput>): StepFunctionDefinition<TInput, TOutput>;
    static delay(_options: DelayOptions): void;
    static sequential<T>(_array: readonly T[]): SequentialIterable<T>;
    /**
     * Wrap an array for use with for...of, with optional Map state configuration.
     * Supports maxConcurrency and closures (outer variable capture).
     *
     * @example
     *   for (const item of Steps.items(input.items, { maxConcurrency: 5 })) {
     *     await processItem.call({ item, prefix: config.prefix });
     *   }
     */
    static items<T>(_array: readonly T[], _options?: MapOptions): Iterable<T>;
    static format(_template: string, ..._args: any[]): string;
    static add(_a: number, _b: number): number;
    static random(_start: number, _end: number): number;
    static uuid(): string;
    static hash(_data: string, _algorithm: HashAlgorithm): string;
    static base64Encode(_data: string): string;
    static base64Decode(_data: string): string;
    static array(..._items: any[]): any[];
    static arrayPartition<T>(_array: readonly T[], _size: number): T[][];
    static partition<T>(array: readonly T[], size: number): T[][];
    static arrayContains<T>(_array: readonly T[], _value: T): boolean;
    static arrayRange(_start: number, _end: number, _step: number): number[];
    static range(start: number, end: number, step: number): number[];
    static arrayGetItem<T>(_array: readonly T[], _index: number): T;
    static arrayLength<T>(_array: readonly T[]): number;
    static arrayUnique<T>(_array: readonly T[]): T[];
    static unique<T>(array: readonly T[]): T[];
    static arraySlice<T>(_array: readonly T[], _start: number, _end: number): T[];
    static jsonParse(_str: string): any;
    static jsonStringify(_obj: any): string;
    static merge(_obj1: any, _obj2: any, _deep?: boolean): any;
    /**
     * Iterate over an array and execute the callback for each item,
     * compiling to a Map state with optional concurrency control.
     *
     * @example
     *   const results = await Steps.map(input.items, async (item) => {
     *     return await processItem.call({ item });
     *   }, { maxConcurrency: 10 });
     */
    static map<T, R>(_items: readonly T[], _callback: (item: T) => Promise<R>, _options?: MapOptions): Promise<R[]>;
    /**
     * Distributed Map: large-scale parallel iteration with S3-based I/O.
     * Compiles to a Map state with ProcessorConfig DISTRIBUTED.
     *
     * @example
     *   const results = await Steps.distributedMap(
     *     input.items,
     *     async (item) => { return await processItem.call({ item }); },
     *     {
     *       maxConcurrency: 1000,
     *       itemReader: {
     *         Resource: 'arn:aws:states:::s3:getObject',
     *         ReaderConfig: { InputType: 'CSV' },
     *         Parameters: { Bucket: 'my-bucket', Key: 'data.csv' },
     *       },
     *       resultWriter: {
     *         Resource: 'arn:aws:states:::s3:putObject',
     *         Parameters: { Bucket: 'my-bucket', Prefix: 'results/' },
     *       },
     *       toleratedFailurePercentage: 5,
     *       label: 'ProcessRecords',
     *     },
     *   );
     */
    static distributedMap<T, R>(_items: readonly T[], _callback: (item: T) => Promise<R>, _options?: DistributedMapOptions): Promise<R[]>;
    /**
     * Escape hatch for data flow analysis.
     *
     * Wraps a value that the compiler cannot prove is constant, but the
     * developer knows will be available at runtime. The compiler emits a
     * warning (SS708) instead of an error, and passes the value through
     * unchanged to the ASL output.
     *
     * @example
     *   const arn = getArnFromConfig();
     *   const svc = Lambda<Req, Res>(Steps.safeVar(arn));
     */
    static safeVar<T>(_value: T): T;
    /**
     * Direct SDK integration for any AWS service not covered by the
     * built-in bindings. Compiles to a Task state with:
     *   Resource: "arn:aws:states:::aws-sdk:<service>:<action>"
     *
     * @example
     *   const result = await Steps.awsSdk<
     *     { Bucket: string; Key: string },
     *     { Body: string }
     *   >('S3', 'GetObject', { Bucket: 'my-bucket', Key: input.key });
     */
    static awsSdk<TInput extends Record<string, any> = Record<string, any>, TOutput = any>(_service: string, _action: string, _parameters: TInput): Promise<TOutput>;
    /**
     * Emit an explicit Succeed state. Terminates the current execution path.
     *
     * @example
     *   Steps.succeed();
     */
    static succeed(): never;
    /**
     * Execute branches in parallel with optional retry configuration.
     * Compiles to ASL Parallel state with Retry rules.
     *
     * @example
     *   const [a, b] = await Steps.parallel(
     *     [() => svc1.call(input), () => svc2.call(input)],
     *     { retry: { errorEquals: ['States.ALL'], maxAttempts: 3 } },
     *   );
     */
    static parallel<T extends readonly unknown[]>(_branches: {
        [K in keyof T]: () => Promise<T[K]>;
    }, _options?: ParallelOptions): Promise<T>;
}
export declare class SimpleStepContext {
    readonly execution: {
        readonly id: string;
        readonly name: string;
        readonly startTime: string;
        readonly roleArn: string;
        readonly input: any;
        readonly redriveCount: number;
        readonly redriveStatus: string;
    };
    readonly state: {
        readonly name: string;
        readonly enteredTime: string;
        readonly retryCount: number;
    };
    readonly stateMachine: {
        readonly id: string;
        readonly name: string;
    };
    readonly task: {
        readonly token: string;
    };
    readonly map: {
        readonly item: {
            readonly index: number;
            readonly value: any;
        };
    };
    constructor();
    getInput<T>(): T;
}
export declare class StepException extends Error {
}
export declare class TimeoutError extends StepException {
}
export declare class TaskFailedError extends StepException {
}
export declare class PermissionsError extends StepException {
}
export declare class HeartbeatTimeoutError extends StepException {
}
export declare class BranchFailedError extends StepException {
}
export declare class NoChoiceMatchedError extends StepException {
}
export declare class IntrinsicFailureError extends StepException {
}
export declare class ResultPathMatchFailureError extends StepException {
}
export declare class ParameterPathFailureError extends StepException {
}
export declare class ItemReaderFailedError extends StepException {
}
export declare class ResultWriterFailedError extends StepException {
}
export declare class ExceedToleratedFailureError extends StepException {
}
/**
 * Maps built-in error class names to ASL error strings.
 * Custom StepException subclasses not in this map use their class name directly.
 */
export declare const STEP_ERROR_NAMES: Record<string, string>;
export declare function stepFunction(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
//# sourceMappingURL=index.d.ts.map