Core types

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 TriggerConfig = 
  | QueueTrigger
  | ApiTrigger
  | CronTrigger
  | StateTrigger
  | StreamTrigger

type QueueTrigger<TSchema extends StepSchemaInput | undefined = any> = {
  type: 'queue'
  topic: string
  input?: TSchema
  condition?: TriggerCondition
  infrastructure?: Partial<InfrastructureConfig>
}

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[]
  condition?: TriggerCondition
}

type CronTrigger = {
  type: 'cron'
  expression: string
  condition?: TriggerCondition
}

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 StepHandler<TInput = any, TEnqueueData = never> = (
  input: TriggerInput<TInput>,
  ctx: FlowContext<TEnqueueData, TriggerInput<TInput>>
) => Promise<ApiResponse | void>

type Handlers<TConfig extends StepConfig> = (
  input: InferHandlerInput<TConfig>,
  ctx: FlowContext<InferEnqueues<TConfig>, InferHandlerInput<TConfig>>
) => Promise<ApiResponse | void>

type TriggerInput<T> =
  | T                           // Queue trigger
  | ApiRequest<T>               // HTTP trigger
  | undefined                   // Cron trigger
  | StateTriggerInput<T>        // State trigger
  | StreamTriggerInput<T>       // Stream trigger

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

type ApiResponse<TStatus extends number = number, TBody = any> = {
  status: TStatus
  headers?: Record<string, string>
  body: TBody
}

return {
  status: 200,
  headers: { 'content-type': 'application/json' },
  body: { success: true, data: result },
}

interface MotiaHttpArgs<TBody = unknown> {
  request: MotiaHttpRequest<TBody>
  response: MotiaHttpResponse
}

interface MotiaHttpRequest<TBody = unknown> {
  pathParams: Record<string, string>
  queryParams: Record<string, string | string[]>
  body: TBody
  headers: Record<string, string | string[]>
  method: string
  requestBody: ChannelReader
}

interface MotiaHttpResponse {
  status: (statusCode: number) => void
  headers: (headers: Record<string, string>) => void
  stream: NodeJS.WritableStream
  close: () => void
}

type StateTriggerInput<T> = {
  type: 'state'
  group_id: string
  item_id: string
  old_value?: T
  new_value?: T
}

import type { StateTriggerInput } from 'motia'

interface Order {
  id: string
  status: string
}

const condition = (input: StateTriggerInput<Order>) => {
  return (
    input.group_id === 'orders' &&
    input.old_value?.status !== 'shipped' &&
    input.new_value?.status === 'shipped'
  )
}

type StreamTriggerInput<T> = {
  type: 'stream'
  timestamp: number
  streamName: string
  groupId: string
  id: string
  event: StreamEvent<T>
}

type StreamEvent<T> =
  | { type: 'create', data: T }
  | { type: 'update', data: T }
  | { type: 'delete', data: T }

import type { StreamTriggerInput } from 'motia'

interface Progress {
  completed: number
  total: number
}

const condition = (input: StreamTriggerInput<Progress>) => {
  return (
    input.event.type === 'update' &&
    input.event.data.completed === input.event.data.total
  )
}

interface FlowContext<TEnqueueData = never, TInput = unknown> {
  enqueue: Enqueuer<TEnqueueData>
  traceId: string
  state: InternalStateManager
  logger: Logger
  streams: Streams
  trigger: TriggerInfo
  is: TriggerTypeGuards<TInput>
  getData: () => ExtractDataPayload<TInput>
  match: <TResult>(handlers: MatchHandlers<TInput, TEnqueueData, TResult>) => Promise<TResult | undefined>
}

type TriggerInfo = {
  type: 'http' | 'queue' | 'cron' | 'state' | 'stream'
  index?: number
  path?: string
  method?: string
  topic?: string
  expression?: string
}

type Enqueuer<TData> = (event: {
  topic: string
  data: TData
  messageGroupId?: string
}) => Promise<void>

type StepSchemaInput = ZodType | JsonSchema | TypedJsonSchema

type TypedJsonSchema<T = unknown> = JsonSchema & { 
  readonly __phantomType?: T 
}

import { jsonSchema } from 'motia'
import { z } from 'zod'

const schema = jsonSchema(
  z.object({
    name: z.string(),
    age: z.number(),
  })
)

// TypeScript knows the inferred type
type User = z.infer<typeof schema>

type InfrastructureConfig = {
  handler?: Partial<HandlerConfig>
  queue?: Partial<QueueConfig>
}

type HandlerConfig = {
  ram: number        // Memory in MB
  cpu?: number       // CPU units
  timeout: number    // Timeout in seconds
}

type QueueConfig = {
  type: 'fifo' | 'standard'
  maxRetries: number
  visibilityTimeout: number
  delaySeconds: number
}

import { queue } from 'motia'

const trigger = queue('heavy-processing', {
  input: dataSchema,
  infrastructure: {
    handler: {
      ram: 2048,
      timeout: 300,
    },
    queue: {
      type: 'fifo',
      maxRetries: 3,
      visibilityTimeout: 120,
    },
  },
})

interface StreamConfig {
  name: string
  schema: StepSchemaInput
  baseConfig: { storageType: 'default' }
  onJoin?: (
    subscription: StreamSubscription,
    context: FlowContext,
    authContext?: StreamContext
  ) => Promise<StreamJoinResult>
  onLeave?: (
    subscription: StreamSubscription,
    context: FlowContext,
    authContext?: StreamContext
  ) => Promise<void>
}

type StreamSubscription = {
  groupId: string
  id?: string
}

type StreamSetResult<T> = {
  value: T
  version: number
  timestamp: number
}

type UpdateOp = 
  | { op: 'add', path: string, value: any }
  | { op: 'remove', path: string }
  | { op: 'replace', path: string, value: any }
  | { op: 'move', from: string, path: string }
  | { op: 'copy', from: string, path: string }
  | { op: 'test', path: string, value: any }

type TriggerCondition<TInput = unknown> = (
  input: TriggerInput<TInput>,
  ctx: FlowContext<never, TriggerInput<TInput>>
) => boolean | Promise<boolean>

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

type ApiRouteMethod = 
  | 'GET' 
  | 'POST' 
  | 'PUT' 
  | 'DELETE' 
  | 'PATCH' 
  | 'OPTIONS' 
  | 'HEAD'

interface QueryParam {
  name: string
  description: string
}

import { step, http, queue } from 'motia'
import { z } from 'zod'

const dataSchema = z.object({
  userId: z.string(),
  amount: z.number(),
})

const config = {
  name: 'ProcessPayment',
  triggers: [
    http('POST', '/payments', { bodySchema: dataSchema }),
    queue('payments', { input: dataSchema }),
  ],
  enqueues: ['notifications'],
} as const satisfies StepConfig

// Handler input type is automatically inferred
export const { handler } = step(config, async (input, ctx) => {
  // TypeScript knows the shape of input based on triggers
  if (ctx.is.http(input)) {
    // input.body: { userId: string, amount: number }
  }
  
  if (ctx.is.queue(input)) {
    // input: { userId: string, amount: number }
  }
  
  // ctx.enqueue is type-checked against 'notifications'
  await ctx.enqueue({
    topic: 'notifications',
    data: { message: 'Payment processed' },
  })
})