import { p as Primitive, t as AnyCredentialSet } from "./CredentialSet-lUr_8nN3.mjs";
import { c as AnyZodSchema, d as InputSchema, l as InferSchema, p as JsonObject, u as InferSchemaOrUndefined } from "./schemas-DXcT2SRm.mjs";
import { n as AnyMcpServer } from "./McpServer-BsxD4QgA.mjs";
import { t as AnyMessagingGateway } from "./types-BsYmmIlq.mjs";
import { a as SkillSource, n as AnySandbox } from "./Sandbox-JUa1Ghwp.mjs";
import { C as TriggerEntry, M as Duration, T as ValidTriggerEntry } from "./index-BqY2HTnE.mjs";
import { f as RetryConfig, n as AnyOperation } from "./Operation-BKM2cNZp.mjs";
import { y as ResolvedCredentialSet } from "./credential-requirements-PoSYqj0L.mjs";
import { z } from "zod";

//#region src/agent/schemas.d.ts
declare const AgentManifestSchema: z.ZodObject<{
  manifestVersion: z.ZodLiteral<1>;
  type: z.ZodLiteral<"agent">;
  id: z.ZodString;
  authoredAgentId: z.ZodString;
  name: z.ZodString;
  runtimeKind: z.ZodEnum<{
    declarative: "declarative";
    runnable: "runnable";
  }>;
  description: z.ZodOptional<z.ZodString>;
  systemPrompt: z.ZodString;
  model: z.ZodString;
  thinkingLevel: z.ZodEnum<{
    off: "off";
    minimal: "minimal";
    low: "low";
    medium: "medium";
    high: "high";
    xhigh: "xhigh";
  }>;
  input: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
  output: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
  maxSteps: z.ZodNumber;
  credentialSets: z.ZodOptional<z.ZodArray<z.ZodObject<{
    manifestVersion: z.ZodLiteral<1>;
    type: z.ZodLiteral<"credentialSet">;
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    auth: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
    credentialType: z.ZodEnum<{
      oauth: "oauth";
      manual: "manual";
    }>;
    exposure: z.ZodOptional<z.ZodEnum<{
      "user-runtime": "user-runtime";
      "platform-only": "platform-only";
    }>>;
    proxy: z.ZodOptional<z.ZodObject<{
      hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
      hostPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
      injection: z.ZodOptional<z.ZodObject<{
        headers: z.ZodOptional<z.ZodBoolean>;
        basicAuth: z.ZodOptional<z.ZodBoolean>;
        queryParams: z.ZodOptional<z.ZodBoolean>;
        body: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>>;
    needsRawSecret: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>>>;
  tools: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    displayName: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    sourceKind: z.ZodEnum<{
      operation: "operation";
      workflow: "workflow";
    }>;
    authoredOperationId: z.ZodOptional<z.ZodString>;
    authoredWorkflowId: z.ZodOptional<z.ZodString>;
    integrationId: z.ZodOptional<z.ZodString>;
    largeResultMode: z.ZodOptional<z.ZodEnum<{
      reject: "reject";
      ref: "ref";
    }>>;
    midSessionSnapshot: z.ZodOptional<z.ZodBoolean>;
    credentialSets: z.ZodOptional<z.ZodArray<z.ZodObject<{
      id: z.ZodString;
      required: z.ZodBoolean;
    }, z.core.$strip>>>;
  }, z.core.$strip>>;
  skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
    path: z.ZodString;
  }, z.core.$strip>>>;
  enableMemory: z.ZodDefault<z.ZodBoolean>;
  enableDatabase: z.ZodDefault<z.ZodBoolean>;
  mcpServers: z.ZodArray<z.ZodObject<{
    manifestVersion: z.ZodLiteral<1>;
    type: z.ZodLiteral<"mcpServer">;
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    transport: z.ZodDiscriminatedUnion<[z.ZodObject<{
      type: z.ZodLiteral<"stdio">;
      command: z.ZodString;
      args: z.ZodOptional<z.ZodArray<z.ZodString>>;
      env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strip>, z.ZodObject<{
      type: z.ZodLiteral<"http">;
      url: z.ZodString;
      headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strip>, z.ZodObject<{
      type: z.ZodLiteral<"sse">;
      url: z.ZodString;
      headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strip>], "type">;
    credentialSets: z.ZodArray<z.ZodObject<{
      manifestVersion: z.ZodLiteral<1>;
      type: z.ZodLiteral<"credentialSet">;
      id: z.ZodString;
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      auth: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
      credentialType: z.ZodEnum<{
        oauth: "oauth";
        manual: "manual";
      }>;
      exposure: z.ZodOptional<z.ZodEnum<{
        "user-runtime": "user-runtime";
        "platform-only": "platform-only";
      }>>;
      proxy: z.ZodOptional<z.ZodObject<{
        hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
        hostPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        injection: z.ZodOptional<z.ZodObject<{
          headers: z.ZodOptional<z.ZodBoolean>;
          basicAuth: z.ZodOptional<z.ZodBoolean>;
          queryParams: z.ZodOptional<z.ZodBoolean>;
          body: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      needsRawSecret: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    credentialInjection: z.ZodOptional<z.ZodObject<{
      env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        credentialSetId: z.ZodString;
        key: z.ZodString;
      }, z.core.$strip>>>;
      headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        credentialSetId: z.ZodString;
        key: z.ZodString;
      }, z.core.$strip>>>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  sandbox: z.ZodOptional<z.ZodObject<{
    manifestVersion: z.ZodLiteral<1>;
    type: z.ZodLiteral<"sandbox">;
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    workdir: z.ZodOptional<z.ZodString>;
    runCommands: z.ZodArray<z.ZodString>;
    setupCommands: z.ZodArray<z.ZodString>;
    credentialSets: z.ZodArray<z.ZodObject<{
      manifestVersion: z.ZodLiteral<1>;
      type: z.ZodLiteral<"credentialSet">;
      id: z.ZodString;
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      auth: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
      credentialType: z.ZodEnum<{
        oauth: "oauth";
        manual: "manual";
      }>;
      exposure: z.ZodOptional<z.ZodEnum<{
        "user-runtime": "user-runtime";
        "platform-only": "platform-only";
      }>>;
      proxy: z.ZodOptional<z.ZodObject<{
        hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
        hostPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        injection: z.ZodOptional<z.ZodObject<{
          headers: z.ZodOptional<z.ZodBoolean>;
          basicAuth: z.ZodOptional<z.ZodBoolean>;
          queryParams: z.ZodOptional<z.ZodBoolean>;
          body: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      needsRawSecret: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
      kind: z.ZodLiteral<"literal">;
      value: z.ZodString;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"credential">;
      credentialSetId: z.ZodString;
      key: z.ZodString;
    }, z.core.$strip>], "kind">>>;
    fileSources: z.ZodArray<z.ZodObject<{
      path: z.ZodString;
      target: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  messaging: z.ZodOptional<z.ZodArray<z.ZodObject<{
    manifestVersion: z.ZodLiteral<1>;
    type: z.ZodLiteral<"messaging-gateway">;
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    provider: z.ZodString;
    mode: z.ZodEnum<{
      custom: "custom";
      official: "official";
    }>;
    credentialSet: z.ZodObject<{
      manifestVersion: z.ZodLiteral<1>;
      type: z.ZodLiteral<"credentialSet">;
      id: z.ZodString;
      name: z.ZodString;
      description: z.ZodOptional<z.ZodString>;
      auth: z.ZodType<JsonObject, unknown, z.core.$ZodTypeInternals<JsonObject, unknown>>;
      credentialType: z.ZodEnum<{
        oauth: "oauth";
        manual: "manual";
      }>;
      exposure: z.ZodOptional<z.ZodEnum<{
        "user-runtime": "user-runtime";
        "platform-only": "platform-only";
      }>>;
      proxy: z.ZodOptional<z.ZodObject<{
        hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
        hostPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        injection: z.ZodOptional<z.ZodObject<{
          headers: z.ZodOptional<z.ZodBoolean>;
          basicAuth: z.ZodOptional<z.ZodBoolean>;
          queryParams: z.ZodOptional<z.ZodBoolean>;
          body: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
      }, z.core.$strip>>;
      needsRawSecret: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>;
    credentialScope: z.ZodOptional<z.ZodEnum<{
      organization: "organization";
      project: "project";
    }>>;
    appRef: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>>>;
}, z.core.$strip>;
type AgentManifest = z.infer<typeof AgentManifestSchema>;
//#endregion
//#region src/internal/workflow-step-context-overrides.d.ts
interface WorkflowStepContextOverrides {
  readonly attempt?: number;
  readonly credentials?: Record<string, Record<string, unknown>>;
  readonly maxAttempts?: number;
  readonly stepId?: string;
}
//#endregion
//#region src/artifacts/flow-graph-schema.d.ts
declare const FlowGraphSchema: z.ZodObject<{
  nodes: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<{
      entry: "entry";
      step: "step";
      "code-block": "code-block";
      decision: "decision";
      merge: "merge";
      fork: "fork";
      join: "join";
      "parallel-map": "parallel-map";
      loop: "loop";
      exit: "exit";
    }>;
    label: z.ZodString;
    position: z.ZodObject<{
      x: z.ZodNumber;
      y: z.ZodNumber;
    }, z.core.$strip>;
    data: z.ZodDiscriminatedUnion<[z.ZodObject<{
      kind: z.ZodLiteral<"entry">;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"call">;
      callKind: z.ZodEnum<{
        agent: "agent";
        "workflow-step": "workflow-step";
        tool: "tool";
        hook: "hook";
        "child-workflow": "child-workflow";
        "function-call": "function-call";
        "method-call": "method-call";
        "dynamic-call": "dynamic-call";
        "parallel-call": "parallel-call";
        "process-exit": "process-exit";
        iife: "iife";
        expression: "expression";
      }>;
      stepName: z.ZodString;
      callsiteFingerprint: z.ZodOptional<z.ZodString>;
      exportName: z.ZodOptional<z.ZodString>;
      stepId: z.ZodOptional<z.ZodString>;
      awaited: z.ZodOptional<z.ZodBoolean>;
      dynamic: z.ZodOptional<z.ZodBoolean>;
      recursive: z.ZodOptional<z.ZodBoolean>;
      importSource: z.ZodOptional<z.ZodObject<{
        kind: z.ZodEnum<{
          local: "local";
          "module-import": "module-import";
          "namespace-import": "namespace-import";
          dynamic: "dynamic";
        }>;
        moduleSpecifier: z.ZodOptional<z.ZodString>;
        importName: z.ZodOptional<z.ZodString>;
        localName: z.ZodOptional<z.ZodString>;
        resolvedPath: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>;
      outputBinding: z.ZodOptional<z.ZodString>;
      description: z.ZodOptional<z.ZodString>;
      inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
      source: z.ZodOptional<z.ZodObject<{
        filePath: z.ZodString;
        absoluteFilePath: z.ZodOptional<z.ZodString>;
        line: z.ZodNumber;
        column: z.ZodNumber;
        position: z.ZodOptional<z.ZodNumber>;
        endLine: z.ZodNumber;
        endColumn: z.ZodNumber;
        endPosition: z.ZodOptional<z.ZodNumber>;
        synthetic: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      astKind: z.ZodOptional<z.ZodString>;
      scopeOverride: z.ZodOptional<z.ZodEnum<{
        organization: "organization";
        project: "project";
        user_provided_credential: "user_provided_credential";
      }>>;
      credentialSets: z.ZodOptional<z.ZodArray<z.ZodObject<{
        resolvedId: z.ZodString;
        scope: z.ZodOptional<z.ZodEnum<{
          organization: "organization";
          project: "project";
          user_provided_credential: "user_provided_credential";
        }>>;
        alias: z.ZodOptional<z.ZodString>;
        credentialRef: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
          type: z.ZodLiteral<"id">;
          id: z.ZodString;
        }, z.core.$strip>, z.ZodObject<{
          type: z.ZodLiteral<"name">;
          name: z.ZodString;
        }, z.core.$strip>], "type">>;
        credentialKeys: z.ZodArray<z.ZodString>;
        optionalCredentialKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
        storedCredentialKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
        optionalStoredCredentialKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
        proxy: z.ZodOptional<z.ZodObject<{
          hosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
          hostPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
          injection: z.ZodOptional<z.ZodObject<{
            headers: z.ZodOptional<z.ZodBoolean>;
            basicAuth: z.ZodOptional<z.ZodBoolean>;
            queryParams: z.ZodOptional<z.ZodBoolean>;
            body: z.ZodOptional<z.ZodBoolean>;
          }, z.core.$strip>>;
        }, z.core.$strip>>;
        needsRawSecret: z.ZodOptional<z.ZodBoolean>;
        needsDynamicResolution: z.ZodOptional<z.ZodBoolean>;
        dynamicResolutionCacheMs: z.ZodOptional<z.ZodNumber>;
        onCredentialRevoked: z.ZodOptional<z.ZodEnum<{
          fail: "fail";
          "retry-once": "retry-once";
        }>>;
        schemaFingerprint: z.ZodOptional<z.ZodString>;
      }, z.core.$strip>>>;
      requiredOAuthScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"code-block">;
      statements: z.ZodArray<z.ZodObject<{
        kind: z.ZodString;
        label: z.ZodString;
        sourceText: z.ZodString;
      }, z.core.$strip>>;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"decision">;
      decisionKind: z.ZodOptional<z.ZodEnum<{
        if: "if";
        switch: "switch";
        ternary: "ternary";
      }>>;
      source: z.ZodOptional<z.ZodObject<{
        filePath: z.ZodString;
        absoluteFilePath: z.ZodOptional<z.ZodString>;
        line: z.ZodNumber;
        column: z.ZodNumber;
        position: z.ZodOptional<z.ZodNumber>;
        endLine: z.ZodNumber;
        endColumn: z.ZodNumber;
        endPosition: z.ZodOptional<z.ZodNumber>;
        synthetic: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      astKind: z.ZodOptional<z.ZodString>;
      conditionText: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"merge">;
      source: z.ZodOptional<z.ZodObject<{
        filePath: z.ZodString;
        absoluteFilePath: z.ZodOptional<z.ZodString>;
        line: z.ZodNumber;
        column: z.ZodNumber;
        position: z.ZodOptional<z.ZodNumber>;
        endLine: z.ZodNumber;
        endColumn: z.ZodNumber;
        endPosition: z.ZodOptional<z.ZodNumber>;
        synthetic: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"fork">;
      parallelKind: z.ZodOptional<z.ZodEnum<{
        any: "any";
        all: "all";
        race: "race";
        allSettled: "allSettled";
      }>>;
      preStatements: z.ZodOptional<z.ZodArray<z.ZodObject<{
        kind: z.ZodString;
        label: z.ZodString;
        sourceText: z.ZodString;
      }, z.core.$strip>>>;
      source: z.ZodOptional<z.ZodObject<{
        filePath: z.ZodString;
        absoluteFilePath: z.ZodOptional<z.ZodString>;
        line: z.ZodNumber;
        column: z.ZodNumber;
        position: z.ZodOptional<z.ZodNumber>;
        endLine: z.ZodNumber;
        endColumn: z.ZodNumber;
        endPosition: z.ZodOptional<z.ZodNumber>;
        synthetic: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      astKind: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"join">;
      outputBinding: z.ZodOptional<z.ZodString>;
      source: z.ZodOptional<z.ZodObject<{
        filePath: z.ZodString;
        absoluteFilePath: z.ZodOptional<z.ZodString>;
        line: z.ZodNumber;
        column: z.ZodNumber;
        position: z.ZodOptional<z.ZodNumber>;
        endLine: z.ZodNumber;
        endColumn: z.ZodNumber;
        endPosition: z.ZodOptional<z.ZodNumber>;
        synthetic: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"parallel-map">;
      parallelKind: z.ZodOptional<z.ZodEnum<{
        any: "any";
        all: "all";
        race: "race";
        allSettled: "allSettled";
      }>>;
      iterationExpression: z.ZodOptional<z.ZodString>;
      stepNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
      outputBinding: z.ZodOptional<z.ZodString>;
      preStatements: z.ZodOptional<z.ZodArray<z.ZodObject<{
        kind: z.ZodString;
        label: z.ZodString;
        sourceText: z.ZodString;
      }, z.core.$strip>>>;
      source: z.ZodOptional<z.ZodObject<{
        filePath: z.ZodString;
        absoluteFilePath: z.ZodOptional<z.ZodString>;
        line: z.ZodNumber;
        column: z.ZodNumber;
        position: z.ZodOptional<z.ZodNumber>;
        endLine: z.ZodNumber;
        endColumn: z.ZodNumber;
        endPosition: z.ZodOptional<z.ZodNumber>;
        synthetic: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      astKind: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"loop">;
      loopKind: z.ZodOptional<z.ZodEnum<{
        for: "for";
        "for-of": "for-of";
        "for-in": "for-in";
        while: "while";
        "do-while": "do-while";
      }>>;
      source: z.ZodOptional<z.ZodObject<{
        filePath: z.ZodString;
        absoluteFilePath: z.ZodOptional<z.ZodString>;
        line: z.ZodNumber;
        column: z.ZodNumber;
        position: z.ZodOptional<z.ZodNumber>;
        endLine: z.ZodNumber;
        endColumn: z.ZodNumber;
        endPosition: z.ZodOptional<z.ZodNumber>;
        synthetic: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      astKind: z.ZodOptional<z.ZodString>;
      conditionText: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>, z.ZodObject<{
      kind: z.ZodLiteral<"exit">;
      exitKind: z.ZodEnum<{
        return: "return";
        throw: "throw";
      }>;
      sourceText: z.ZodOptional<z.ZodString>;
      source: z.ZodOptional<z.ZodObject<{
        filePath: z.ZodString;
        absoluteFilePath: z.ZodOptional<z.ZodString>;
        line: z.ZodNumber;
        column: z.ZodNumber;
        position: z.ZodOptional<z.ZodNumber>;
        endLine: z.ZodNumber;
        endColumn: z.ZodNumber;
        endPosition: z.ZodOptional<z.ZodNumber>;
        synthetic: z.ZodOptional<z.ZodBoolean>;
      }, z.core.$strip>>;
      astKind: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>], "kind">;
  }, z.core.$strip>>;
  edges: z.ZodArray<z.ZodObject<{
    id: z.ZodString;
    source: z.ZodString;
    target: z.ZodString;
    type: z.ZodEnum<{
      default: "default";
      merge: "merge";
      "true-branch": "true-branch";
      "false-branch": "false-branch";
      "loop-entry": "loop-entry";
      "loop-back": "loop-back";
      parallel: "parallel";
      return: "return";
    }>;
    label: z.ZodOptional<z.ZodString>;
    data: z.ZodOptional<z.ZodObject<{
      branchKind: z.ZodOptional<z.ZodEnum<{
        then: "then";
        else: "else";
        "parallel-branch": "parallel-branch";
      }>>;
    }, z.core.$catchall<z.ZodUnknown>>>;
  }, z.core.$strip>>;
  entryPoint: z.ZodString;
  exitPoints: z.ZodArray<z.ZodString>;
  generatedAt: z.ZodISODateTime;
  diagnostics: z.ZodArray<z.ZodString>;
}, z.core.$strip>;
type FlowGraph = z.infer<typeof FlowGraphSchema>;
//#endregion
//#region src/flow-graph/types.d.ts
/**
 * A .run() call site found by the AST parser.
 * Represents a potential step, agent, or child workflow call before static resolution.
 */
interface ASTCandidate {
  /** The identifier before .run() — e.g. "fetchUser" from fetchUser.run(...) */
  readonly calleeName: string;
  /** Variable name the result is assigned to, if any */
  readonly outputBinding: string | undefined;
  /** Whether the call is awaited */
  readonly awaited: boolean;
  /** Sequential index in AST source order */
  readonly sourceOrderIndex: number;
  /** SWC span for source location mapping */
  readonly span: {
    start: number;
    end: number;
  };
}
//#endregion
//#region src/flow-graph/matching.d.ts
interface StaticImportSource {
  kind: 'local' | 'module-import' | 'namespace-import' | 'dynamic';
  moduleSpecifier?: string;
  importName?: string;
  localName?: string;
  resolvedPath?: string;
}
interface StaticCandidateResolution {
  callKind: 'workflow-step' | 'agent' | 'child-workflow';
  displayName: string;
  exportName?: string;
  importSource?: StaticImportSource;
  description?: string;
  inputSchema?: Record<string, unknown>;
  outputSchema?: Record<string, unknown>;
  credentialSets?: ResolvedCredentialSet[];
  requiredOAuthScopes?: readonly string[];
  nestedRunSource?: string;
  manifest?: {
    type?: string;
    name?: string;
    description?: string;
    input?: unknown;
    output?: unknown;
    workflowSchemas?: {
      input?: unknown;
      output?: unknown;
    };
    requiredOAuthScopes?: readonly string[];
    credentialSets?: Array<{
      id: string;
      auth?: {
        properties?: Record<string, unknown>;
      };
      stored?: {
        properties?: Record<string, unknown>;
      };
      proxy?: unknown;
      needsRawSecret?: boolean;
      onCredentialRevoked?: 'fail' | 'retry-once';
      connections?: readonly Record<string, unknown>[];
    }>;
  };
}
//#endregion
//#region src/flow-graph/graph-builder.d.ts
interface GenerateFlowGraphOptions {
  readonly resolveCandidate?: (candidate: ASTCandidate) => StaticCandidateResolution | undefined;
}
declare function generateFlowGraph(workflow: Workflow<AnyZodSchema, AnyZodSchema, AnyZodSchema | undefined>, options?: GenerateFlowGraphOptions): Promise<FlowGraph>;
//#endregion
//#region src/workflow/Workflow.d.ts
declare class Workflow<TInputSchema extends AnyZodSchema, TOutputSchema extends AnyZodSchema, TWorkflowGlobalsSchema extends AnyZodSchema | undefined = undefined> extends Primitive<WorkflowManifest> {
  #private;
  readonly kind: "workflow";
  readonly author?: string;
  readonly description?: string;
  readonly id: string;
  readonly input: TInputSchema;
  readonly name: string;
  readonly output: TOutputSchema;
  readonly tags: readonly string[];
  readonly version?: string;
  readonly timeout?: Duration;
  readonly largeResultMode?: 'reject' | 'ref';
  readonly midSessionSnapshot: boolean;
  readonly retries?: RetryConfig;
  readonly triggers: readonly TriggerEntry[];
  readonly workflowGlobals?: TWorkflowGlobalsSchema;
  constructor(config: WorkflowConfig<TInputSchema, TOutputSchema, TWorkflowGlobalsSchema>);
  withTimeout(duration: Duration): Workflow<TInputSchema, TOutputSchema, TWorkflowGlobalsSchema>;
  retry(policy: RetryConfig): Workflow<TInputSchema, TOutputSchema, TWorkflowGlobalsSchema>;
  run(input: z.input<TInputSchema>, runtimeOrContextOrOptions?: (WorkflowRunContext<InferSchemaOrUndefined<TWorkflowGlobalsSchema>> & WorkflowRunOptions) | (WorkflowRuntime<InferSchemaOrUndefined<TWorkflowGlobalsSchema>> & WorkflowRunOptions) | WorkflowRunOptions): Promise<z.output<TOutputSchema>>;
  toManifest(): WorkflowManifest;
  /**
   * Resolves a trigger payload into workflow input using the bound transform.
   * Looks up the trigger by its authored id (the `id` field passed to
   * `xxxTrigger({ id: ... })`).
   *
   * For bare triggers, payload passes through input.parse().
   * For bound triggers with transform, runs transform then input.parse().
   */
  resolveTriggerInput(authoredTriggerId: string, payload: unknown, ctx?: unknown): Promise<z.output<TInputSchema>>;
  /**
   * Build a static flow graph from this workflow's `run` source.
   *
   * For CLI/build metadata loading only. Deployed `workflow.js` bundles do not
   * include the flow-graph module; use prebuilt `flow.json` at runtime.
   */
  toFlowGraph(options?: GenerateFlowGraphOptions): Promise<FlowGraph>;
  getRunFunctionSource(): string;
}
//#endregion
//#region src/workflow/schemas.d.ts
declare const WorkflowManifestSchema: z.ZodObject<{
  schemaVersion: z.ZodLiteral<"1.0.0">;
  id: z.ZodString;
  name: z.ZodString;
  description: z.ZodOptional<z.ZodString>;
  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
  exportName: z.ZodString;
  workflowSchemas: z.ZodObject<{
    input: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    output: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  }, z.core.$strip>;
  workflowGlobals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
  timeout: z.ZodOptional<z.ZodType<Duration, unknown, z.core.$ZodTypeInternals<Duration, unknown>>>;
  triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
    authoredTriggerId: z.ZodString;
    triggerType: z.ZodEnum<{
      cron: "cron";
      polling: "polling";
      webhook: "webhook";
    }>;
    hasTransform: z.ZodBoolean;
    narrowedFrom: z.ZodOptional<z.ZodString>;
    lineage: z.ZodOptional<z.ZodArray<z.ZodString>>;
  }, z.core.$strip>>>;
}, z.core.$strip>;
type WorkflowManifest = z.infer<typeof WorkflowManifestSchema>;
declare const workflowConfigSchema: z.ZodObject<{
  author: z.ZodOptional<z.ZodString>;
  description: z.ZodOptional<z.ZodString>;
  id: z.ZodString;
  input: z.ZodCustom<AnyZodSchema, AnyZodSchema>;
  name: z.ZodString;
  output: z.ZodCustom<AnyZodSchema, AnyZodSchema>;
  timeout: z.ZodOptional<z.ZodType<Duration, unknown, z.core.$ZodTypeInternals<Duration, unknown>>>;
  largeResultMode: z.ZodOptional<z.ZodEnum<{
    reject: "reject";
    ref: "ref";
  }>>;
  midSessionSnapshot: z.ZodOptional<z.ZodBoolean>;
  retries: z.ZodOptional<z.ZodObject<{
    constant: z.ZodOptional<z.ZodObject<{
      attempts: z.ZodNumber;
      seconds: z.ZodNumber;
    }, z.core.$strip>>;
    exponential: z.ZodOptional<z.ZodObject<{
      attempts: z.ZodNumber;
      base: z.ZodOptional<z.ZodNumber>;
      multiplier: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
  }, z.core.$strip>>;
  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
  version: z.ZodOptional<z.ZodString>;
  workflowGlobals: z.ZodOptional<z.ZodCustom<AnyZodSchema, AnyZodSchema>>;
  run: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
  triggers: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
}, z.core.$strip>;
//#endregion
//#region src/workflow/types.d.ts
/** Rich hook interface for workflow suspension points. Canonical source of truth for hook shape. */
interface Hook<T = unknown> extends PromiseLike<T> {
  readonly token: Promise<string>;
  readonly resumeUrl: Promise<string>;
  readonly cancelUrl: Promise<string>;
  readonly approvalPageUrl: Promise<string>;
}
interface WaitOptions {
  intent?: 'rate-limit' | 'data-settlement' | 'temporal-window' | 'inline-pacing';
  reason?: string;
}
interface CreateHookOptions {
  intent?: 'human-decision' | 'user-input' | 'external-system' | 'multi-actor';
  prompt?: string;
  responseSchema?: unknown;
  requiredActors?: readonly string[];
  reason?: string;
  token?: string;
  requiredApprovals?: number;
}
type WorkflowRunContext<TWorkflowGlobals = undefined> = Readonly<{
  createHook: (name: string, options?: CreateHookOptions) => Hook;
  wait: (duration: string, options?: WaitOptions) => Promise<void>;
  hasCredentialSet: (id: string) => boolean;
  workflowGlobals: TWorkflowGlobals;
  workflowId: string;
}>;
type AnyWorkflow = Workflow<AnyZodSchema, AnyZodSchema, AnyZodSchema | undefined>;
interface WorkflowRunOptions {
  readonly timeout?: Duration;
}
interface WorkflowRuntime<TWorkflowGlobals = unknown> {
  readonly context: WorkflowRunContext<TWorkflowGlobals>;
  readonly stepContext?: WorkflowStepContextOverrides;
  readonly handleStep?: (operation: AnyOperation, input: unknown) => Promise<unknown>;
  readonly handleChildWorkflow?: (workflow: AnyWorkflow, input: unknown) => Promise<unknown>;
  readonly handleAgent?: (agent: AnyAgent, input: unknown) => Promise<unknown>;
}
type WorkflowRun<TInputSchema extends AnyZodSchema, TOutputSchema extends AnyZodSchema, TWorkflowGlobalsSchema extends AnyZodSchema | undefined = undefined> = (input: InferSchema<TInputSchema>, ctx: WorkflowRunContext<InferSchemaOrUndefined<TWorkflowGlobalsSchema>>) => Promise<InferSchema<TOutputSchema>>;
interface WorkflowBaseConfig<TInputSchema extends AnyZodSchema, TOutputSchema extends AnyZodSchema, TWorkflowGlobalsSchema extends AnyZodSchema | undefined = undefined> {
  readonly author?: string;
  readonly description?: string;
  readonly id: string;
  readonly input: TInputSchema;
  readonly name: string;
  readonly output: TOutputSchema;
  readonly tags?: readonly string[];
  readonly timeout?: Duration;
  readonly largeResultMode?: 'reject' | 'ref';
  readonly midSessionSnapshot?: boolean;
  readonly retries?: RetryConfig;
  /** Triggers that start this workflow. Bare triggers pass payload through as input. Bound triggers (from calling trigger with { transform, filter }) map payload to input. */
  readonly triggers?: readonly ValidTriggerEntry<InferSchema<TInputSchema>>[];
  readonly version?: string;
  readonly workflowGlobals?: TWorkflowGlobalsSchema;
}
interface WorkflowConfig<TInputSchema extends AnyZodSchema, TOutputSchema extends AnyZodSchema, TWorkflowGlobalsSchema extends AnyZodSchema | undefined = undefined> extends WorkflowBaseConfig<TInputSchema, TOutputSchema, TWorkflowGlobalsSchema> {
  readonly run: WorkflowRun<TInputSchema, TOutputSchema, TWorkflowGlobalsSchema>;
}
type WorkflowInput<TWorkflow> = TWorkflow extends Workflow<infer TInputSchema, AnyZodSchema, AnyZodSchema | undefined> ? InputSchema<TInputSchema> : never;
type WorkflowOutput<TWorkflow> = TWorkflow extends Workflow<AnyZodSchema, infer TOutputSchema, AnyZodSchema | undefined> ? InferSchema<TOutputSchema> : never;
//#endregion
//#region src/agent/types.d.ts
interface HookResult {
  allow: boolean;
  replacement?: unknown;
}
interface StepInfo {
  stepNumber: number;
  type: 'tool_call' | 'text' | 'thinking';
  toolName?: string;
  content?: string;
}
interface AgentHooks {
  onToolStart?: (tool: string, input: unknown) => Promise<HookResult>;
  onToolEnd?: (tool: string, result: unknown) => Promise<void>;
  onStep?: (step: StepInfo) => Promise<void>;
}
type AgentEventType = 'tool_call' | 'tool_result' | 'text' | 'thinking' | 'user_message' | 'step' | 'error' | 'retry_start' | 'retry_end' | 'done';
interface AgentEvent {
  type: AgentEventType;
  eventId?: string;
  timestamp?: string;
  messageId?: string;
  toolCallId?: string;
  tool?: string;
  input?: unknown;
  output?: unknown;
  content?: string;
  stepNumber?: number;
  error?: Error;
}
interface AgentMessage {
  role: 'user' | 'assistant' | 'tool';
  content: string;
  toolCallId?: string;
  toolName?: string;
}
interface AgentSession {
  id: string;
  agentId: string;
  messages: AgentMessage[];
  createdAt: Date;
  updatedAt: Date;
}
interface AgentResult {
  output: unknown;
  session: AgentSession;
  steps: number;
  toolCalls: Array<{
    tool: string;
    input: unknown;
    output: unknown;
  }>;
}
interface AgentEventSink {
  onEvent?: (event: {
    eventType: string;
    eventData: Record<string, unknown>;
    stepNumber?: number;
    timestamp: string;
  }) => void | Promise<void>;
  onFinalize?: (result: {
    events: Array<{
      eventType: string;
      eventData: Record<string, unknown>;
      stepNumber?: number;
      timestamp: string;
    }>;
    totalSteps: number;
    totalToolCalls: number;
    durationMs: number;
  }) => void | Promise<void>;
}
interface AgentRunOptions {
  sandbox?: {
    id: string;
    close(): Promise<void>;
    [key: string]: unknown;
  };
  credentialProvider?: (credentialSetId: string, keys: string[], context: Record<string, unknown>) => Promise<Record<string, string>>;
  credentials?: Record<string, unknown>;
  session?: AgentSession;
  abortSignal?: AbortSignal;
  hooks?: AgentHooks;
  eventSink?: AgentEventSink;
}
declare const AGENT_RUNTIME_KIND_DECLARATIVE = "declarative";
declare const AGENT_RUNTIME_KIND_RUNNABLE = "runnable";
type AgentRuntimeKind = typeof AGENT_RUNTIME_KIND_DECLARATIVE | typeof AGENT_RUNTIME_KIND_RUNNABLE;
type AgentThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
interface WorkflowSafeAgentReference {
  kind: 'agent';
  authoredAgentId: string;
  displayName: string;
  runtimeKind: AgentRuntimeKind;
  inputSchema?: JsonObject;
  outputSchema?: JsonObject;
  authoredExport?: {
    exportName?: string;
    filePath?: string;
  };
  metadata?: JsonObject;
}
type AnyAgentToolEntry = AnyOperation | AnyWorkflow;
interface AgentConfig<TInputSchema extends AnyZodSchema = z.ZodString, TOutputSchema extends AnyZodSchema = z.ZodUnknown> {
  readonly id: string;
  readonly name: string;
  readonly description?: string;
  readonly systemPrompt: string;
  readonly model: string;
  readonly thinkingLevel?: AgentThinkingLevel;
  readonly input?: TInputSchema;
  readonly output?: TOutputSchema;
  readonly tools?: readonly AnyAgentToolEntry[];
  readonly mcpServers?: readonly AnyMcpServer[];
  readonly sandbox?: AnySandbox;
  readonly skills?: readonly SkillSource[];
  readonly enableMemory?: boolean;
  readonly enableDatabase?: boolean;
  readonly maxSteps?: number;
  readonly messaging?: readonly AnyMessagingGateway[];
  readonly hooks?: AgentHooks;
  readonly run?: (input: InferSchema<TInputSchema>, options?: AgentRunOptions) => Promise<AgentResult>;
  readonly stream?: (input: InferSchema<TInputSchema>, options?: AgentRunOptions) => AsyncIterable<AgentEvent>;
}
type AnyAgent = Agent<AnyZodSchema, AnyZodSchema>;
//#endregion
//#region src/agent/Agent.d.ts
declare class Agent<TInputSchema extends AnyZodSchema = z.ZodString, TOutputSchema extends AnyZodSchema = z.ZodUnknown> extends Primitive<AgentManifest> {
  #private;
  readonly kind: "agent";
  readonly id: string;
  readonly name: string;
  readonly description?: string;
  readonly systemPrompt: string;
  readonly model: string;
  readonly thinkingLevel: string;
  readonly input: TInputSchema;
  readonly output: TOutputSchema;
  readonly allCredentialSets: readonly AnyCredentialSet[];
  readonly tools: readonly AnyAgentToolEntry[];
  readonly mcpServers: readonly AnyMcpServer[];
  readonly sandbox?: AnySandbox;
  readonly messaging: readonly AnyMessagingGateway[];
  readonly skills: readonly SkillSource[];
  readonly enableMemory: boolean;
  readonly enableDatabase: boolean;
  readonly maxSteps: number;
  readonly hooks?: AgentHooks;
  readonly runtimeKind: AgentRuntimeKind;
  readonly workflowSafeReference: WorkflowSafeAgentReference;
  constructor(config: AgentConfig<TInputSchema, TOutputSchema>);
  run(input: InferSchema<TInputSchema>, options?: AgentRunOptions): Promise<AgentResult>;
  stream(input: InferSchema<TInputSchema>, options?: AgentRunOptions): AsyncIterable<AgentEvent>;
  configure(overrides: {
    name?: string;
    description?: string;
    maxSteps?: number;
    hooks?: AgentHooks;
  }): Agent<TInputSchema, TOutputSchema>;
  getCredentialRequirements(): {
    credentialSetId: string;
    credentialType: "oauth" | "manual";
    credentialKeys: string[];
    optionalCredentialKeys?: string[] | undefined;
    storedCredentialKeys?: string[] | undefined;
    optionalStoredCredentialKeys?: string[] | undefined;
    schemaFingerprint?: string | undefined;
    needsDynamicResolution?: boolean | undefined;
    dynamicResolutionCacheMs?: number | undefined;
    onCredentialRevoked?: "fail" | "retry-once" | undefined;
    proxy?: {
      hosts?: string[] | undefined;
      hostPatterns?: string[] | undefined;
      injection?: {
        headers?: boolean | undefined;
        basicAuth?: boolean | undefined;
        queryParams?: boolean | undefined;
        body?: boolean | undefined;
      } | undefined;
    } | undefined;
    needsRawSecret?: boolean | undefined;
    requiredOAuthScopes?: string[] | undefined;
  }[];
  toManifest(): AgentManifest;
}
//#endregion
export { AgentManifestSchema as C, AgentManifest as S, WorkflowManifestSchema as _, AnyAgentToolEntry as a, GenerateFlowGraphOptions as b, Hook as c, WorkflowOutput as d, WorkflowRun as f, WorkflowManifest as g, WorkflowRuntime as h, AnyAgent as i, WorkflowConfig as l, WorkflowRunOptions as m, AgentConfig as n, WorkflowSafeAgentReference as o, WorkflowRunContext as p, AgentResult as r, AnyWorkflow as s, Agent as t, WorkflowInput as u, workflowConfigSchema as v, generateFlowGraph as x, Workflow as y };