import "dotenv/config";
import { ChannelReader, ChannelReader as ChannelReader$1, ChannelWriter, ISdk, InitOptions, Logger, Logger as Logger$1 } from "iii-sdk";
import * as z from "zod";
import { ZodType } from "zod";
import { StreamAuthInput, StreamAuthResult, StreamAuthResult as StreamAuthResult$1, StreamContext, StreamContext as StreamContext$1, StreamJoinResult, StreamJoinResult as StreamJoinResult$1, StreamSetInput, StreamSetResult, StreamSetResult as StreamSetResult$1, UpdateOp, UpdateOp as UpdateOp$1 } from "iii-sdk/stream";
import { FromSchema } from "json-schema-to-ts";
import { JSONSchema } from "zod/v4/core";

//#region src/types/schema.types.d.ts
type JsonSchema = JSONSchema.BaseSchema;
//#endregion
//#region src/types.d.ts
type ZodInput = ZodType<any, any, any>;
type TypedJsonSchema<T$1 = unknown> = JsonSchema & {
  readonly __phantomType?: T$1;
};
type StepSchemaInput = ZodInput | JsonSchema | TypedJsonSchema<unknown>;
declare function jsonSchema<T$1 extends z.ZodType>(schema: T$1): TypedJsonSchema<z.output<T$1>>;
type InternalStateManager = {
  get<T$1>(groupId: string, key: string): Promise<T$1 | null>;
  set<T$1>(groupId: string, key: string, value: T$1): Promise<StreamSetResult$1<T$1> | null>;
  update<T$1>(groupId: string, key: string, ops: UpdateOp$1[]): Promise<StreamSetResult$1<T$1> | null>;
  delete<T$1>(groupId: string, key: string): Promise<T$1 | null>;
  list<T$1>(groupId: string): Promise<T$1[]>;
  clear(groupId: string): Promise<void>;
};
type EnqueueData<T$1 = unknown> = {
  topic: string;
  data: T$1;
  messageGroupId?: string;
};
type Enqueuer<TData> = (event: TData) => Promise<void>;
type ExtractQueueInput<TInput> = Exclude<Exclude<Exclude<TInput, ApiRequest>, MotiaHttpArgs>, undefined>;
type ExtractApiInput<TInput> = Extract<TInput, ApiRequest | MotiaHttpArgs>;
type ExtractStateInput<TInput> = Extract<TInput, StateTriggerInput<unknown>>;
type ExtractStreamInput<TInput> = Extract<TInput, StreamTriggerInput<unknown>>;
type ExtractDataPayload<TInput> = TInput extends ApiRequest<infer TBody> ? TBody : TInput extends MotiaHttpArgs<infer TBody> ? TBody : TInput extends undefined ? undefined : TInput;
type MatchHandlers<TInput, _TEnqueueData, TResult> = {
  queue?: (input: ExtractQueueInput<TInput>) => Promise<void>;
  http?: (request: ExtractApiInput<TInput>) => Promise<TResult>;
  cron?: () => Promise<void>;
  state?: (input: ExtractStateInput<TInput>) => Promise<TResult>;
  stream?: (input: ExtractStreamInput<TInput>) => Promise<TResult>;
  default?: (input: TInput) => Promise<TResult | undefined>;
};
interface FlowContext<TEnqueueData = never, TInput = unknown> {
  traceId: string;
  trigger: TriggerInfo;
  is: {
    queue: (input: TInput) => input is ExtractQueueInput<TInput>;
    http: (input: TInput) => input is ExtractApiInput<TInput>;
    cron: (input: TInput) => input is never;
    state: (input: TInput) => input is ExtractStateInput<TInput>;
    stream: (input: TInput) => input is ExtractStreamInput<TInput>;
  };
  /**
   * Extracts the data payload from the input, regardless of trigger type.
   * Useful when multiple triggers (e.g., queue and API) share the same data schema.
   *
   * - For API triggers: returns `request.body`
   * - For queue triggers: returns the queue data directly
   * - For cron triggers: returns `undefined`
   *
   * @example
   * ```ts
   * // When queue and API triggers have the same schema
   * const orderData = ctx.getData() // Works for both triggers
   * ```
   */
  getData: () => ExtractDataPayload<TInput>;
  match: <TResult = any>(handlers: MatchHandlers<TInput, TEnqueueData, TResult>) => Promise<TResult | undefined>;
}
type Enqueue = string | {
  topic: string;
  label?: string;
  conditional?: boolean;
};
type TriggerType = 'http' | 'queue' | 'cron' | 'state' | 'stream';
type TriggerInfo = {
  type: TriggerType;
  index?: number;
  path?: string;
  method?: string;
  topic?: string;
  expression?: string;
};
type QueueTriggerInput<T$1> = T$1;
type ApiTriggerInput<T$1> = ApiRequest<T$1>;
type CronTriggerInput = undefined;
type StateTriggerInput<T$1> = {
  type: 'state';
  group_id: string;
  item_id: string;
  old_value?: T$1;
  new_value?: T$1;
};
type StreamEvent<TData> = {
  type: 'create';
  data: TData;
} | {
  type: 'update';
  data: TData;
} | {
  type: 'delete';
  data: TData;
};
type StreamTriggerInput<T$1> = {
  type: 'stream';
  timestamp: number;
  streamName: string;
  groupId: string;
  id: string;
  event: StreamEvent<T$1>;
};
type TriggerInput<T$1> = QueueTriggerInput<T$1> | ApiTriggerInput<T$1> | CronTriggerInput | StateTriggerInput<T$1> | StreamTriggerInput<T$1>;
type TriggerCondition<TInput = unknown> = (input: TriggerInput<TInput>, ctx: FlowContext<never, TriggerInput<TInput>>) => boolean | Promise<boolean>;
type HandlerConfig = {
  ram: number;
  cpu?: number;
  timeout: number;
};
type QueueConfig = {
  type: 'fifo' | 'standard';
  maxRetries: number;
  visibilityTimeout: number;
  delaySeconds: number;
  concurrency?: number;
  backoffType?: string;
  backoffDelayMs?: number;
};
type ApiRouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
type ApiMiddleware<TBody = unknown, TEnqueueData = never> = (req: MotiaHttpArgs<TBody>, ctx: FlowContext<TEnqueueData, MotiaHttpArgs<TBody>>, next: () => Promise<ApiResponse | void>) => Promise<ApiResponse | void>;
interface QueryParam {
  name: string;
  description: string;
}
type StateTrigger<TSchema extends StepSchemaInput | undefined = any> = {
  type: 'state';
  condition?: TriggerCondition<InferSchema<TSchema>>;
};
type StreamTrigger<TSchema extends StepSchemaInput | undefined = any> = {
  type: 'stream';
  streamName: string;
  groupId?: string;
  itemId?: string;
  condition?: TriggerCondition<InferSchema<TSchema>>;
};
type QueueTrigger<TSchema extends StepSchemaInput | undefined = any> = {
  type: 'queue';
  topic: string;
  input?: TSchema;
  condition?: TriggerCondition<TSchema extends ZodInput ? z.infer<TSchema> : unknown>;
  config?: Partial<QueueConfig>;
};
type ApiTrigger<TSchema extends StepSchemaInput | undefined = any> = {
  type: 'http';
  path: string;
  method: ApiRouteMethod;
  bodySchema?: TSchema;
  responseSchema?: Record<number, StepSchemaInput>;
  queryParams?: readonly QueryParam[];
  middleware?: readonly ApiMiddleware<any, any>[];
  condition?: TriggerCondition<TSchema extends ZodInput ? z.infer<TSchema> : unknown>;
};
type CronTrigger = {
  type: 'cron';
  expression: string;
  input?: never;
  condition?: TriggerCondition;
};
type TriggerConfig = QueueTrigger | ApiTrigger | CronTrigger | StateTrigger | StreamTrigger;
type StepConfig = {
  name: string;
  description?: string;
  triggers: readonly TriggerConfig[];
  enqueues?: readonly Enqueue[];
  virtualEnqueues?: readonly Enqueue[];
  virtualSubscribes?: readonly string[];
  flows?: readonly string[];
  includeFiles?: readonly string[];
};
type MotiaHttpResponse = {
  status: (statusCode: number) => void;
  headers: (headers: Record<string, string>) => void;
  stream: NodeJS.WritableStream;
  close: () => void;
};
interface ApiRequest<TBody = unknown> {
  pathParams: Record<string, string>;
  queryParams: Record<string, string | string[]>;
  body: TBody;
  headers: Record<string, string | string[]>;
}
interface MotiaHttpRequest<TBody = unknown> {
  pathParams: Record<string, string>;
  queryParams: Record<string, string | string[]>;
  body: TBody;
  headers: Record<string, string | string[]>;
  method: string;
  requestBody: ChannelReader$1;
}
interface MotiaHttpArgs<TBody = unknown> {
  request: MotiaHttpRequest<TBody>;
  response: MotiaHttpResponse;
}
type ApiResponse<TStatus extends number = number, TBody = any> = {
  status: TStatus;
  headers?: Record<string, string>;
  body: TBody;
};
type StepHandler<TInput = any, TEnqueueData = never> = (input: TriggerInput<TInput>, ctx: FlowContext<TEnqueueData, TriggerInput<TInput>>) => Promise<ApiResponse | void>;
type Event<TData = unknown> = {
  topic: string;
  data: TData;
  traceId: string;
  flows?: string[];
  logger: Logger$1;
  messageGroupId?: string;
};
type Handler<TData = unknown> = (event: Event<TData>) => Promise<void>;
type SubscribeConfig<TData> = {
  queue: string;
  handlerName: string;
  filePath: string;
  handler: Handler<TData>;
};
type UnsubscribeConfig = {
  filePath: string;
  queue: string;
};
type Step = {
  filePath: string;
  config: StepConfig;
};
type Flow = {
  name: string;
  description?: string;
  steps: Step[];
};
interface Streams {}
interface Enqueues {}
type InferSchema<T$1, TFallback = unknown> = T$1 extends TypedJsonSchema<infer O> ? O : T$1 extends ZodInput ? z.infer<T$1> : T$1 extends {
  readonly type: string;
} ? FromSchema<T$1 & {
  type: any;
}> : T$1 extends {
  readonly anyOf: readonly any[];
} ? FromSchema<T$1 & {
  anyOf: any;
}> : T$1 extends {
  readonly allOf: readonly any[];
} ? FromSchema<T$1 & {
  allOf: any;
}> : T$1 extends {
  readonly oneOf: readonly any[];
} ? FromSchema<T$1 & {
  oneOf: any;
}> : T$1 extends undefined ? unknown : TFallback;
type InferBodySchema<S$1> = S$1 extends ZodInput ? z.infer<S$1> : S$1 extends StepSchemaInput ? InferSchema<S$1> : unknown;
type TriggerToInput<TTrigger> = TTrigger extends {
  type: 'queue';
  input?: infer S;
} ? S extends ZodInput ? z.infer<S> : S extends StepSchemaInput ? InferSchema<S> : unknown : TTrigger extends {
  type: 'http';
  bodySchema?: infer S;
} ? MotiaHttpArgs<InferBodySchema<S>> : TTrigger extends {
  type: 'state';
} ? StateTriggerInput<unknown> : TTrigger extends {
  type: 'stream';
} ? StreamTriggerInput<unknown> : TTrigger extends {
  type: 'cron';
} ? undefined : never;
type InferHandlerInput$1<TConfig extends StepConfig> = TriggerToInput<TConfig['triggers'][number]>;
type InferReturnType = Promise<ApiResponse | void>;
type EnqueueTopic<T$1 extends string> = T$1 extends keyof Enqueues ? Enqueues[T$1] : unknown;
type NormalizeEnqueue<E> = E extends string ? {
  topic: E;
} : E extends {
  topic: infer T extends string;
} ? {
  topic: T;
} : never;
type EnqueueElement<E> = NormalizeEnqueue<E> extends {
  topic: infer T extends string;
} ? {
  topic: T;
  data: EnqueueTopic<T>;
} : never;
type InferEnqueues<T$1> = T$1 extends {
  enqueues: readonly unknown[];
} ? EnqueueElement<T$1['enqueues'][number]> : never;
type Handlers<TConfig extends StepConfig> = (input: InferHandlerInput$1<TConfig>, ctx: FlowContext<InferEnqueues<TConfig>, InferHandlerInput$1<TConfig>>) => InferReturnType;
//#endregion
//#region src/guards.d.ts
type ApiTriggerType = Extract<TriggerConfig, {
  type: 'http';
}>;
type QueueTriggerType = Extract<TriggerConfig, {
  type: 'queue';
}>;
type CronTriggerType = Extract<TriggerConfig, {
  type: 'cron';
}>;
type StateTriggerType = Extract<TriggerConfig, {
  type: 'state';
}>;
type StreamTriggerType = Extract<TriggerConfig, {
  type: 'stream';
}>;
declare const isApiTrigger: (trigger: TriggerConfig) => trigger is ApiTriggerType;
declare const isQueueTrigger: (trigger: TriggerConfig) => trigger is QueueTriggerType;
declare const isCronTrigger: (trigger: TriggerConfig) => trigger is CronTriggerType;
declare const isStateTrigger: (trigger: TriggerConfig) => trigger is StateTriggerType;
declare const isStreamTrigger: (trigger: TriggerConfig) => trigger is StreamTriggerType;
declare const getApiTriggers: (step: Step) => ApiTriggerType[];
declare const getQueueTriggers: (step: Step) => QueueTriggerType[];
declare const getCronTriggers: (step: Step) => CronTriggerType[];
declare const getStateTriggers: (step: Step) => StateTriggerType[];
declare const getStreamTriggers: (step: Step) => StreamTriggerType[];
//#endregion
//#region src/multi-trigger.d.ts
type StepDefinition$1<TConfig extends StepConfig> = {
  config: TConfig;
  handler: Handlers<TConfig>;
};
type InferHandlerInput<TConfig extends StepConfig> = TConfig extends StepConfig ? Parameters<Handlers<TConfig>>[0] : never;
type TriggerHandlers<TConfig extends StepConfig> = {
  queue?: (input: ExtractQueueInput<InferHandlerInput<TConfig>>, ctx: Omit<FlowContext<any, any>, 'match'>) => Promise<void>;
  http?: (request: ExtractApiInput<InferHandlerInput<TConfig>>, ctx: Omit<FlowContext<any, any>, 'match'>) => Promise<any>;
  cron?: (ctx: Omit<FlowContext<any, any>, 'match'>) => Promise<void>;
  state?: (input: ExtractStateInput<InferHandlerInput<TConfig>>, ctx: Omit<FlowContext<any, any>, 'match'>) => Promise<any>;
  stream?: (input: ExtractStreamInput<InferHandlerInput<TConfig>>, ctx: Omit<FlowContext<any, any>, 'match'>) => Promise<any>;
};
type MultiTriggerStepBuilder<TConfig extends StepConfig> = {
  config: TConfig;
  handlers: (handlers: TriggerHandlers<TConfig>) => StepDefinition$1<TConfig>;
  onQueue: (handler: TriggerHandlers<TConfig>['queue']) => MultiTriggerStepBuilder<TConfig> & {
    handlers: () => StepDefinition$1<TConfig>;
  };
  onHttp: (handler: TriggerHandlers<TConfig>['http']) => MultiTriggerStepBuilder<TConfig> & {
    handlers: () => StepDefinition$1<TConfig>;
  };
  onCron: (handler: TriggerHandlers<TConfig>['cron']) => MultiTriggerStepBuilder<TConfig> & {
    handlers: () => StepDefinition$1<TConfig>;
  };
  onState: (handler: TriggerHandlers<TConfig>['state']) => MultiTriggerStepBuilder<TConfig> & {
    handlers: () => StepDefinition$1<TConfig>;
  };
  onStream: (handler: TriggerHandlers<TConfig>['stream']) => MultiTriggerStepBuilder<TConfig> & {
    handlers: () => StepDefinition$1<TConfig>;
  };
};
declare function multiTriggerStep<const TConfig extends StepConfig>(config: TConfig): MultiTriggerStepBuilder<TConfig>;
//#endregion
//#region src/types-stream.d.ts
type StreamSubscription = {
  groupId: string;
  id?: string;
};
interface StreamAuthInput$1 {
  headers: Record<string, string>;
  path: string;
  queryParams: Record<string, string[]>;
  addr: string;
}
type AuthenticateStream = (input: StreamAuthInput$1, context: FlowContext) => Promise<StreamAuthResult$1>;
type PromiseOrValue<T$1> = T$1 | Promise<T$1>;
interface StreamConfig {
  name: string;
  schema: StepSchemaInput;
  baseConfig: {
    storageType: 'default';
  };
  onJoin?: (subscription: StreamSubscription, context: FlowContext, authContext?: StreamContext$1) => PromiseOrValue<StreamJoinResult$1>;
  onLeave?: (subscription: StreamSubscription, context: FlowContext, authContext?: StreamContext$1) => PromiseOrValue<void>;
}
type StateStreamEventChannel = {
  groupId: string;
  id?: string;
};
type StateStreamEvent<TData> = {
  type: string;
  data: TData;
};
type BaseStreamItem<TData = unknown> = TData & {
  id: string;
};
interface MotiaStream<TData> {
  get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
  set(groupId: string, id: string, data: TData): Promise<StreamSetResult$1<BaseStreamItem<TData>>>;
  delete(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
  getGroup(groupId: string): Promise<BaseStreamItem<TData>[]>;
  update(groupId: string, id: string, data: UpdateOp$1[]): Promise<StreamSetResult$1<BaseStreamItem<TData>>>;
  send<T$1>(channel: StateStreamEventChannel, event: StateStreamEvent<T$1>): Promise<void>;
}
//#endregion
//#region src/new/build/loader.d.ts
declare const generateStepId: (filePath: string) => string;
//#endregion
//#region src/new/stream.d.ts
type InferStreamData<TConfig extends StreamConfig> = StreamConfig extends TConfig ? unknown : InferSchema<TConfig['schema']>;
declare class Stream<TConfig extends StreamConfig = StreamConfig> {
  readonly config: TConfig;
  constructor(config: TConfig);
  get(groupId: string, itemId: string): Promise<InferStreamData<TConfig> | null>;
  set(groupId: string, itemId: string, data: InferStreamData<TConfig>): Promise<StreamSetResult$1<InferStreamData<TConfig>>>;
  delete(groupId: string, itemId: string): Promise<void>;
  list(groupId: string): Promise<InferStreamData<TConfig>[]>;
  update(groupId: string, itemId: string, ops: UpdateOp$1[]): Promise<StreamSetResult$1<InferStreamData<TConfig>>>;
  listGroups(): Promise<string[]>;
  send<T$1>(channel: StateStreamEventChannel, event: StateStreamEvent<T$1>): Promise<void>;
}
//#endregion
//#region src/new/build/utils.d.ts
declare class Motia {
  streams: Record<string, Stream>;
  private authenticateStream;
  addStep(config: StepConfig, stepPath: string, handler: StepHandler<unknown>, filePath: string): void;
  addStream(config: StreamConfig, _streamPath: string): void;
  initialize(): void;
}
//#endregion
//#region src/new/iii.d.ts
type OtelConfig = NonNullable<InitOptions['otel']>;
declare const getInstance: () => ISdk;
declare const initIII: (otelConfig?: Partial<OtelConfig>) => ISdk;
//#endregion
//#region src/new/setup-step-endpoint.d.ts
declare function setupStepEndpoint(iii: ISdk): void;
//#endregion
//#region src/new/state.d.ts
declare class StateManager implements InternalStateManager {
  get<T$1>(scope: string, key: string): Promise<T$1 | null>;
  set<T$1>(scope: string, key: string, value: T$1): Promise<StreamSetResult$1<T$1> | null>;
  delete<T$1>(scope: string, key: string): Promise<T$1 | null>;
  list<T$1>(scope: string): Promise<T$1[]>;
  listGroups(): Promise<string[]>;
  update<T$1>(scope: string, key: string, ops: UpdateOp$1[]): Promise<StreamSetResult$1<T$1> | null>;
  clear(scope: string): Promise<void>;
}
declare const stateManager: StateManager;
//#endregion
//#region src/new/enqueue.d.ts
declare const enqueue: Enqueuer<EnqueueData>;
//#endregion
//#region src/new/logger.d.ts
declare const logger: Logger$1;
//#endregion
//#region src/step.d.ts
type StepDefinition<TConfig extends StepConfig> = {
  config: TConfig;
  handler: Handlers<TConfig>;
};
type StepBuilder<TConfig extends StepConfig> = {
  config: TConfig;
  handle: (handler: Handlers<TConfig>) => StepDefinition<TConfig>;
};
declare function step<TConfig extends StepConfig>(config: TConfig, handler: Handlers<TConfig>): StepDefinition<TConfig>;
declare function step<TConfig extends StepConfig>(config: TConfig): StepBuilder<TConfig>;
//#endregion
//#region src/triggers.d.ts
type ApiOptions<TSchema extends StepSchemaInput | undefined = undefined> = {
  bodySchema?: TSchema;
  responseSchema?: Record<number, StepSchemaInput>;
  queryParams?: readonly QueryParam[];
  middleware?: readonly ApiMiddleware<any, any, any>[];
};
type QueueOptions<TSchema extends StepSchemaInput | undefined = undefined> = {
  input?: TSchema;
  config?: Partial<QueueConfig>;
};
declare function http<TOptions extends ApiOptions<any> | undefined = undefined>(method: ApiRouteMethod, path: string, options?: TOptions, condition?: TriggerCondition): ApiTrigger<TOptions extends ApiOptions<infer S> ? S : undefined>;
/** @deprecated Use http() instead. Will be removed in a future version. */
declare function api<TOptions extends ApiOptions<any> | undefined = undefined>(method: ApiRouteMethod, path: string, options?: TOptions, condition?: TriggerCondition): ApiTrigger<TOptions extends ApiOptions<infer S> ? S : undefined>;
declare function queue<TOptions extends QueueOptions<any> | undefined = undefined>(topic: string, options?: TOptions, condition?: TriggerCondition): QueueTrigger<TOptions extends QueueOptions<infer S> ? S : undefined>;
declare function cron(expression: string, condition?: TriggerCondition): CronTrigger;
declare function state(condition?: TriggerCondition): StateTrigger;
type StreamOptions = {
  groupId?: string;
  itemId?: string;
  condition?: TriggerCondition;
};
declare function stream(streamName: string, optionsOrCondition?: StreamOptions | TriggerCondition): StreamTrigger;
//#endregion
export { ApiMiddleware, ApiRequest, ApiResponse, ApiRouteMethod, ApiTrigger, AuthenticateStream, BaseStreamItem, ChannelReader, ChannelWriter, CronTrigger, Enqueue, EnqueueData, Enqueuer, Enqueues, Event, ExtractApiInput, ExtractDataPayload, ExtractQueueInput, ExtractStateInput, ExtractStreamInput, Flow, FlowContext, Handler, HandlerConfig, Handlers, InferSchema, InternalStateManager, Logger, MatchHandlers, Motia, MotiaHttpArgs, MotiaHttpRequest, MotiaHttpResponse, MotiaStream, QueryParam, QueueConfig, QueueTrigger, StateManager, StateStreamEvent, StateStreamEventChannel, StateTrigger, StateTriggerInput, Step, StepConfig, StepHandler, StepSchemaInput, Stream, type StreamAuthInput, type StreamAuthResult, StreamConfig, type StreamContext, StreamEvent, type StreamJoinResult, type StreamSetInput, type StreamSetResult, StreamSubscription, StreamTrigger, StreamTriggerInput, Streams, SubscribeConfig, TriggerCondition, TriggerConfig, TriggerInfo, TriggerInput, TypedJsonSchema, UnsubscribeConfig, type UpdateOp, ZodInput, api, cron, enqueue, generateStepId, getApiTriggers, getCronTriggers, getInstance, getQueueTriggers, getStateTriggers, getStreamTriggers, http, initIII, isApiTrigger, isCronTrigger, isQueueTrigger, isStateTrigger, isStreamTrigger, jsonSchema, logger, multiTriggerStep, queue, setupStepEndpoint, state, stateManager, step, stream };
//# sourceMappingURL=index.d.mts.map