import {
  B as Think,
  G as ThinkScheduledTasks,
  bt as ThinkMessengers
} from "../think-i1Pkgb1R.js";
import {
  a as ThinkFrameworkFeatureSource,
  c as ThinkFrameworkRoute,
  d as ThinkFrameworkSchedule,
  f as ThinkFrameworkTool,
  g as ThinkWorkerConfigOptions,
  h as ThinkWorkerConfig,
  i as ThinkFrameworkFeature,
  l as ThinkFrameworkRouteSurface,
  m as ThinkPlatformRequirementKind,
  n as ThinkFrameworkAgent,
  o as ThinkFrameworkManifest,
  p as ThinkPlatformRequirement,
  r as ThinkFrameworkBinding,
  s as ThinkFrameworkMessenger,
  t as ThinkAgentDeclarationKind,
  u as ThinkFrameworkRouteSurfaceKind
} from "../manifest-CpB-xngB.js";
import {
  a as ThinkWorkerConfigDiagnostic,
  c as diagnoseThinkManifest,
  d as mergeThinkWorkerConfig,
  f as summarizeThinkManifest,
  i as ThinkRequiredBinding,
  l as diagnoseThinkWorkerConfig,
  n as ThinkConfigMergeResult,
  o as createThinkWorkerConfig,
  r as ThinkConfigSeverity,
  s as createThinkWorkerDefaults,
  t as DiagnoseThinkWorkerConfigOptions,
  u as inferRequiredBindings
} from "../config-D512sQYg.js";
import { LanguageModel, ToolSet } from "ai";
import { SkillScriptRunner, SkillSource } from "agents/skills";
import { Session } from "agents/experimental/memory/session";

//#region src/framework/agent.d.ts
declare const THINK_AGENT_DEFINITION: unique symbol;
interface DeclarativeThinkAgentOptions<
  Env extends Cloudflare.Env = Cloudflare.Env
> {
  model: LanguageModel | ((env: Env) => LanguageModel);
  prompt?: string | ((env: Env) => string);
  tools?: ToolSet | ((env: Env) => ToolSet);
  skills?: SkillSource[] | ((env: Env) => SkillSource[]);
  skillScriptRunner?:
    | SkillScriptRunner
    | ((agent: Think<Cloudflare.Env>) => SkillScriptRunner);
  schedules?: ThinkScheduledTasks | ((env: Env) => ThinkScheduledTasks);
  messengers?: ThinkMessengers | ((env: Env) => ThinkMessengers);
  configureSession?: (
    session: Session,
    agent: Think<Env>
  ) => Session | Promise<Session>;
}
interface DeclarativeThinkAgentDefinition<
  Env extends Cloudflare.Env = Cloudflare.Env
> {
  readonly [THINK_AGENT_DEFINITION]: true;
  readonly kind: "think-agent-definition";
  readonly options: DeclarativeThinkAgentOptions<Env>;
  __toThinkClass(className: string): typeof Think<Env>;
}
declare function agent<Env extends Cloudflare.Env = Cloudflare.Env>(
  options: DeclarativeThinkAgentOptions<Env>
): DeclarativeThinkAgentDefinition<Env>;
//#endregion
//#region src/framework/discovery.d.ts
interface DiscoverThinkAppOptions {
  root?: string;
  routePrefix?: string;
  files: Record<string, string>;
}
declare function discoverThinkApp(
  options: DiscoverThinkAppOptions
): ThinkFrameworkManifest;
//#endregion
//#region src/framework/codegen.d.ts
declare function generateThinkAgentsModule(
  manifest: ThinkFrameworkManifest
): string;
declare function generateThinkManifestModule(
  manifest: ThinkFrameworkManifest
): string;
declare function generateThinkConfigModule(
  manifest: ThinkFrameworkManifest
): string;
declare function generateThinkRouterModule(
  manifest: ThinkFrameworkManifest
): string;
declare function generateThinkServerEntryModule(): string;
declare function generateThinkEntry(manifest: ThinkFrameworkManifest): string;
//#endregion
//#region src/framework/project.d.ts
interface ThinkProjectOptions extends ThinkWorkerConfigOptions {
  files?: Record<string, string>;
  manifest?: ThinkFrameworkManifest;
  allowNonVirtualMain?: boolean;
}
interface ThinkWranglerConfigResult {
  config: Record<string, unknown> | null;
  error?: string;
  path?: string;
}
declare function resolveThinkManifest(
  options: ThinkProjectOptions,
  root: string,
  watchFile?: (file: string) => void
): Promise<ThinkFrameworkManifest>;
declare function readProjectFiles(
  root: string,
  directory: string,
  watchFile?: (file: string) => void
): Promise<Record<string, string>>;
declare function watchWranglerConfigFiles(
  root: string,
  watchFile: (file: string) => void
): void;
declare function applyUserBindingNames(
  manifest: ThinkFrameworkManifest,
  userConfig: Record<string, unknown>
): void;
declare function readWranglerConfig(
  root: string
): Promise<ThinkWranglerConfigResult>;
declare function createThinkProjectWorkerConfigResult(
  options?: ThinkProjectOptions,
  root?: string
): Promise<ThinkConfigMergeResult>;
declare function createThinkProject(
  options?: ThinkProjectOptions,
  root?: string
): Promise<{
  manifest: ThinkFrameworkManifest;
  workerConfig: ThinkWorkerConfig;
  diagnostics: ThinkWorkerConfigDiagnostic[];
  wranglerConfig: ThinkWranglerConfigResult;
}>;
//#endregion
//#region src/framework/types-codegen.d.ts
interface ThinkTypesCodegenOptions {
  files?: Record<string, string>;
  typesFile?: string;
}
interface ThinkGeneratedFile {
  path: string;
  content: string;
}
declare function generateThinkTypes(
  manifest: ThinkFrameworkManifest,
  options?: ThinkTypesCodegenOptions
): ThinkGeneratedFile[];
declare function isThinkGeneratedFile(source: string): boolean;
//#endregion
export {
  type DeclarativeThinkAgentDefinition,
  type DeclarativeThinkAgentOptions,
  type DiagnoseThinkWorkerConfigOptions,
  type DiscoverThinkAppOptions,
  THINK_AGENT_DEFINITION,
  type ThinkAgentDeclarationKind,
  type ThinkConfigMergeResult,
  type ThinkConfigSeverity,
  type ThinkFrameworkAgent,
  type ThinkFrameworkBinding,
  type ThinkFrameworkFeature,
  type ThinkFrameworkFeatureSource,
  type ThinkFrameworkManifest,
  type ThinkFrameworkMessenger,
  type ThinkFrameworkRoute,
  type ThinkFrameworkRouteSurface,
  type ThinkFrameworkRouteSurfaceKind,
  type ThinkFrameworkSchedule,
  type ThinkFrameworkTool,
  type ThinkGeneratedFile,
  type ThinkPlatformRequirement,
  type ThinkPlatformRequirementKind,
  type ThinkProjectOptions,
  type ThinkRequiredBinding,
  type ThinkTypesCodegenOptions,
  type ThinkWorkerConfig,
  type ThinkWorkerConfigDiagnostic,
  type ThinkWorkerConfigOptions,
  type ThinkWranglerConfigResult,
  agent,
  applyUserBindingNames,
  createThinkProject,
  createThinkProjectWorkerConfigResult,
  createThinkWorkerConfig,
  createThinkWorkerDefaults,
  diagnoseThinkManifest,
  diagnoseThinkWorkerConfig,
  discoverThinkApp,
  generateThinkAgentsModule,
  generateThinkConfigModule,
  generateThinkEntry,
  generateThinkManifestModule,
  generateThinkRouterModule,
  generateThinkServerEntryModule,
  generateThinkTypes,
  inferRequiredBindings,
  isThinkGeneratedFile,
  mergeThinkWorkerConfig,
  readProjectFiles,
  readWranglerConfig,
  resolveThinkManifest,
  summarizeThinkManifest,
  watchWranglerConfigFiles
};
//# sourceMappingURL=index.d.ts.map