//#region src/nextclaw-sdk/types.d.ts
type LogFn = (message: string) => void;
type SecretRefSource = "env" | "file" | "exec";
type DmPolicy = "open" | "pairing" | "allowlist";
type BaseProbeResult<TTarget = string> = {
  ok: boolean;
  target?: TTarget;
  error?: string;
  [key: string]: unknown;
};
type ChannelMeta = {
  id: string;
  label: string;
  selectionLabel?: string;
  docsPath?: string;
  docsLabel?: string;
  blurb?: string;
  aliases?: string[];
  order?: number;
  [key: string]: unknown;
};
type ChannelPlugin<ResolvedAccount = unknown> = {
  id: string;
  meta: ChannelMeta;
  config?: Record<string, unknown>;
  onboarding?: ChannelOnboardingAdapter;
  [key: string]: unknown;
  __resolvedAccountType__?: ResolvedAccount;
};
type AnyAgentTool = {
  name?: string;
  description?: string;
  parameters?: Record<string, unknown>;
  execute?: (toolCallId: string, params: unknown) => Promise<unknown> | unknown;
  [key: string]: unknown;
};
type ResolvedAgentRoute = {
  agentId?: string;
  sessionKey?: string;
  [key: string]: unknown;
};
type InboundDebouncer<T> = {
  run: (key: string, value: T, task: (value: T) => Promise<void>) => void;
  clear: () => void;
};
type PluginRuntime = {
  version?: string;
  config: {
    loadConfig?: () => OpenClawConfig;
    writeConfigFile: (next: OpenClawConfig) => Promise<void>;
  };
  logging: {
    shouldLogVerbose: () => boolean;
  };
  media: {
    detectMime: (params: {
      buffer: Buffer;
    }) => Promise<string | undefined>;
    loadWebMedia: (url: string, options?: Record<string, unknown>) => Promise<Record<string, unknown>>;
  };
  channel: {
    media: {
      fetchRemoteMedia: (params: {
        url: string;
        maxBytes?: number;
      }) => Promise<Record<string, unknown>>;
      saveMediaBuffer: (buffer: Buffer, contentType?: string, direction?: string, maxBytes?: number) => Promise<{
        path: string;
        contentType?: string;
      }>;
    };
    text: {
      chunkMarkdownText: (text: string, limit: number) => string[];
      resolveMarkdownTableMode: (params: Record<string, unknown>) => unknown;
      convertMarkdownTables: (text: string, mode?: unknown) => string;
      resolveTextChunkLimit: (cfg: OpenClawConfig, channel: string, accountId?: string, options?: Record<string, unknown>) => number;
      resolveChunkMode: (cfg: OpenClawConfig, channel: string) => string;
      chunkTextWithMode: (text: string, limit: number, mode?: unknown) => string[];
      hasControlCommand: (text: string, cfg: OpenClawConfig) => boolean;
    };
    reply: {
      resolveEnvelopeFormatOptions: (cfg: OpenClawConfig) => Record<string, unknown>;
      formatAgentEnvelope: (params: Record<string, unknown>) => string;
      finalizeInboundContext: (params: Record<string, unknown>) => Record<string, unknown>;
      withReplyDispatcher: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
      dispatchReplyFromConfig: (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
      createReplyDispatcherWithTyping: (params: Record<string, unknown>) => {
        dispatcher: unknown;
        replyOptions: Record<string, unknown>;
        markDispatchIdle: () => void;
      };
      resolveHumanDelayConfig: (cfg: OpenClawConfig, agentId: string) => unknown;
      dispatchReplyWithBufferedBlockDispatcher?: (params: Record<string, unknown>) => Promise<void>;
    };
    routing: {
      resolveAgentRoute: (params: Record<string, unknown>) => ResolvedAgentRoute | null;
    };
    pairing: {
      readAllowFromStore: (params: {
        channel: string;
        accountId?: string;
      }) => unknown;
      upsertPairingRequest: (params: Record<string, unknown>) => Promise<{
        code: string;
        created: boolean;
      }>;
    };
    commands: {
      shouldComputeCommandAuthorized: (text: string) => boolean;
      resolveCommandAuthorizedFromAuthorizers: (params: Record<string, unknown>) => Promise<boolean> | boolean;
    };
    debounce: {
      resolveInboundDebounceMs: (params: Record<string, unknown>) => number;
      createInboundDebouncer: <T>(params: Record<string, unknown>) => InboundDebouncer<T>;
    };
  };
  [key: string]: unknown;
};
type RuntimeEnv = {
  log?: (message: string) => void;
  error?: (message: string) => void;
  warn?: (message: string) => void;
  debug?: (message: string) => void;
  info?: (message: string) => void;
  [key: string]: unknown;
};
type OpenClawPluginApi = {
  config: ClawdbotConfig;
  runtime: PluginRuntime;
  logger: {
    info: LogFn;
    warn: LogFn;
    error: LogFn;
    debug?: LogFn;
  };
  registerTool: (tool: AnyAgentTool | ((ctx: Record<string, unknown>) => AnyAgentTool | AnyAgentTool[] | null | undefined), opts?: {
    name?: string;
    names?: string[];
    optional?: boolean;
  }) => void;
  registerChannel: (registration: unknown) => void;
  [key: string]: unknown;
};
type WizardSelectOption<T extends string = string> = {
  value: T;
  label: string;
  hint?: string;
};
type WizardPrompter = {
  note: (message: string, title?: string) => Promise<void>;
  text: (params: {
    message: string;
    placeholder?: string;
    initialValue?: string;
    validate?: (value: string) => string | undefined;
  }) => Promise<string>;
  confirm: (params: {
    message: string;
    initialValue?: boolean;
  }) => Promise<boolean>;
  select: <T extends string = string>(params: {
    message: string;
    options: WizardSelectOption<T>[];
    initialValue?: T | string;
  }) => Promise<T>;
};
type ChannelOnboardingDmPolicy = {
  label: string;
  channel: string;
  policyKey: string;
  allowFromKey: string;
  getCurrent: (cfg: ClawdbotConfig) => DmPolicy;
  setPolicy: (cfg: ClawdbotConfig, policy: DmPolicy) => ClawdbotConfig;
  promptAllowFrom: (params: {
    cfg: ClawdbotConfig;
    prompter: WizardPrompter;
  }) => Promise<ClawdbotConfig>;
};
type ChannelOnboardingAdapter = {
  channel: string;
  getStatus: (params: {
    cfg: ClawdbotConfig;
  }) => Promise<{
    channel: string;
    configured: boolean;
    statusLines: string[];
    selectionHint?: string;
    quickstartScore?: number;
  }>;
  configure: (params: {
    cfg: ClawdbotConfig;
    prompter: WizardPrompter;
  }) => Promise<{
    cfg: ClawdbotConfig;
    accountId?: string;
  }>;
  dmPolicy?: ChannelOnboardingDmPolicy;
  disable?: (cfg: ClawdbotConfig) => ClawdbotConfig;
};
type OpenClawConfig = {
  channels?: Record<string, Record<string, unknown> | undefined>;
  bindings?: Array<{
    agentId?: string;
    match?: {
      channel?: string;
      peer?: {
        kind?: string;
        id?: string;
      };
    };
  }>;
  agents?: {
    list?: Array<{
      id: string;
      workspace?: string;
      agentDir?: string;
      [key: string]: unknown;
    }>;
    [key: string]: unknown;
  };
  broadcast?: Record<string, string[]>;
  secrets?: {
    defaults?: {
      env?: string;
      file?: string;
      exec?: string;
    };
    providers?: Record<string, {
      source?: SecretRefSource;
      path?: string;
      mode?: "singleValue" | "json";
      command?: string;
      args?: string[];
      [key: string]: unknown;
    }>;
    [key: string]: unknown;
  };
  [key: string]: unknown;
};
type ClawdbotConfig = OpenClawConfig;
//#endregion
export { AnyAgentTool, BaseProbeResult, ChannelMeta, ChannelOnboardingAdapter, ChannelOnboardingDmPolicy, ChannelPlugin, ClawdbotConfig, DmPolicy, OpenClawConfig, OpenClawPluginApi, PluginRuntime, RuntimeEnv, WizardPrompter };