interface ApiRouteConfig {
  type: 'api'
  name: string
  description?: string
  path: string
  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD'
  emits: Emit[]
  virtualEmits?: Emit[]
  virtualSubscribes?: string[]
  flows?: string[]
  middleware?: ApiMiddleware[]
  bodySchema?: ZodInput
  responseSchema?: Record<number, ZodInput>
  queryParams?: QueryParam[]
  includeFiles?: string[]
}

interface EventConfig {
  type: 'event'
  name: string
  description?: string
  subscribes: string[]
  emits: Emit[]
  virtualEmits?: Emit[]
  input: ZodInput
  flows?: string[]
  includeFiles?: string[]
}

interface CronConfig {
  type: 'cron'
  name: string
  description?: string
  cron: string
  emits: Emit[]
  virtualEmits?: Emit[]
  flows?: string[]
  includeFiles?: string[]
}

interface NoopConfig {
  type: 'noop'
  name: string
  description?: string
  virtualEmits: Emit[]
  virtualSubscribes: string[]
  flows?: string[]
}

interface FlowContext<TEmitData = never> {
  // Event emission
  emit: (event: EmitEvent<TEmitData>) => Promise<void>
  
  // Structured logging
  logger: Logger
  
  // State management
  state: StateManager
  
  // Real-time streams
  streams: StreamsManager
  
  // Request tracing
  traceId: string
}

interface Logger {
  info(message: string, metadata?: Record<string, any>): void
  error(message: string, metadata?: Record<string, any>): void
  warn(message: string, metadata?: Record<string, any>): void
  debug(message: string, metadata?: Record<string, any>): void
}

interface StateManager {
  get<T>(groupId: string, key: string): Promise<T | null>
  set<T>(groupId: string, key: string, value: T): Promise<T>
  delete<T>(groupId: string, key: string): Promise<T | null>
  getGroup<T>(groupId: string): Promise<T[]>
  clear(groupId: string): Promise<void>
}

interface MotiaStream<TData> {
  get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>
  set(groupId: string, id: string, data: TData): Promise<BaseStreamItem<TData>>
  delete(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>
  getGroup(groupId: string): Promise<BaseStreamItem<TData>[]>
  send<T>(channel: StateStreamEventChannel, event: StateStreamEvent<T>): Promise<void>
}

type ApiRouteHandler<
  TRequestBody = unknown,
  TResponseBody extends ApiResponse<number, unknown> = ApiResponse<number, unknown>,
  TEmitData = never
> = (
  req: ApiRequest<TRequestBody>,
  ctx: FlowContext<TEmitData>
) => Promise<TResponseBody>

type EventHandler<
  TInput = unknown,
  TEmitData = never
> = (
  input: TInput,
  ctx: FlowContext<TEmitData>
) => Promise<void>

type CronHandler<TEmitData = never> = (
  ctx: FlowContext<TEmitData>
) => Promise<void>

type ApiMiddleware = (
  req: ApiRequest,
  ctx: FlowContext,
  next: () => Promise<ApiResponse>
) => Promise<ApiResponse>

interface ApiRequest<TBody = unknown> {
  pathParams: Record<string, string>
  queryParams: Record<string, string | string[]>
  body: TBody
  headers: Record<string, string | string[]>
}

interface ApiResponse<TStatus extends number = number, TBody = unknown> {
  status: TStatus
  body: TBody
  headers?: Record<string, string | string[]>
}

interface EmitEvent<TData = unknown> {
  topic: string
  data: TData
}

interface StreamConfig {
  name: string
  schema: ZodInput
  baseConfig: {
    storageType: 'default'
  }
}

type Emit = string | {
  topic: string
  label?: string
  conditional?: boolean
}

interface QueryParam {
  name: string
  description: string
}

interface BaseStreamItem<TData> {
  groupId: string
  id: string
  data: TData
  createdAt: string
  updatedAt: string
}