@gaodefa/daocore 2026.5.99 → 2026.5.100

package/dist/types-CnYaPwf-.d.ts

@@ -0,0 +1,254 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { T as ReplyToMode } from "./types.base-tQh4FMBR.js";
+import { s as ReplyPayload } from "./get-reply-options.types-BXrapyJ-.js";
+import { t as OutboundSendDeps } from "./send-deps-BaEC80iY.js";
+import { t as OutboundMediaAccess } from "./load-options-CTuppEe4.js";
+import { n as PollInput } from "./polls-CfHkU59X.js";
+
+//#region src/channels/message/types.d.ts
+type MessageDurabilityPolicy = "required" | "best_effort" | "disabled";
+declare const durableFinalDeliveryCapabilities: readonly ["text", "media", "poll", "payload", "silent", "replyTo", "thread", "nativeQuote", "messageSendingHooks", "batch", "reconcileUnknownSend", "afterSendSuccess", "afterCommit"];
+type DurableFinalDeliveryCapability = (typeof durableFinalDeliveryCapabilities)[number];
+type DurableFinalDeliveryRequirementMap = Partial<Record<DurableFinalDeliveryCapability, boolean>>;
+type DurableFinalDeliveryPayloadShape = {
+  text?: string | null;
+  replyToId?: string | null;
+  mediaUrl?: string | null;
+  mediaUrls?: readonly (string | null | undefined)[] | null;
+};
+type MessageReceiptSourceResult = {
+  channel?: string;
+  messageId?: string;
+  chatId?: string;
+  channelId?: string;
+  roomId?: string;
+  conversationId?: string;
+  toJid?: string;
+  pollId?: string;
+  timestamp?: number;
+  meta?: Record<string, unknown>;
+};
+type MessageReceiptPartKind = "text" | "media" | "voice" | "poll" | "card" | "preview" | "unknown";
+type MessageReceiptPart = {
+  platformMessageId: string;
+  kind: MessageReceiptPartKind;
+  index: number;
+  threadId?: string;
+  replyToId?: string;
+  raw?: MessageReceiptSourceResult;
+};
+type MessageReceipt = {
+  primaryPlatformMessageId?: string;
+  platformMessageIds: string[];
+  parts: MessageReceiptPart[];
+  threadId?: string;
+  replyToId?: string;
+  editToken?: string;
+  deleteToken?: string;
+  sentAt: number;
+  raw?: readonly MessageReceiptSourceResult[];
+};
+type RenderedMessageBatchPlanKind = "text" | "media" | "voice" | "presentation" | "interactive" | "channelData" | "empty";
+type RenderedMessageBatchPlanItem = {
+  index: number;
+  kinds: readonly RenderedMessageBatchPlanKind[];
+  text?: string;
+  mediaUrls: readonly string[];
+  audioAsVoice?: boolean;
+  presentationBlockCount?: number;
+  hasInteractive?: boolean;
+  hasChannelData?: boolean;
+};
+type RenderedMessageBatchPlan = {
+  payloadCount: number;
+  textCount: number;
+  mediaCount: number;
+  voiceCount: number;
+  presentationCount: number;
+  interactiveCount: number;
+  channelDataCount: number;
+  items: readonly RenderedMessageBatchPlanItem[];
+};
+type RenderedMessageBatch<TPayload = unknown> = {
+  payloads: TPayload[];
+  plan: RenderedMessageBatchPlan;
+};
+type LiveMessagePhase = "idle" | "previewing" | "finalizing" | "finalized" | "cancelled";
+type LiveMessageState<TPayload = unknown> = {
+  phase: LiveMessagePhase;
+  canFinalizeInPlace: boolean;
+  receipt?: MessageReceipt;
+  lastRendered?: RenderedMessageBatch<TPayload>;
+};
+type MessageSendContext<TPayload = unknown, TSendResult = unknown> = {
+  id: string;
+  channel: string;
+  to: string;
+  accountId?: string;
+  durability: Exclude<MessageDurabilityPolicy, "disabled">;
+  attempt: number;
+  signal: AbortSignal;
+  intent?: DurableMessageSendIntent;
+  previousReceipt?: MessageReceipt;
+  preview?: LiveMessageState<TPayload>;
+  render(): Promise<RenderedMessageBatch<TPayload>>;
+  previewUpdate(rendered: RenderedMessageBatch<TPayload>): Promise<LiveMessageState<TPayload>>;
+  send(rendered: RenderedMessageBatch<TPayload>): Promise<TSendResult>;
+  edit(receipt: MessageReceipt, rendered: RenderedMessageBatch<TPayload>): Promise<MessageReceipt>;
+  delete(receipt: MessageReceipt): Promise<void>;
+  commit(receipt: MessageReceipt): Promise<void>;
+  fail(error: unknown): Promise<void>;
+};
+type ChannelMessageSendTextContext<TConfig = DaoCoreConfig> = {
+  cfg: TConfig;
+  to: string;
+  text: string;
+  accountId?: string | null;
+  deps?: OutboundSendDeps;
+  replyToId?: string | null;
+  replyToIdSource?: "explicit" | "implicit";
+  replyToMode?: ReplyToMode;
+  threadId?: string | number | null;
+  silent?: boolean;
+  signal?: AbortSignal;
+  gatewayClientScopes?: readonly string[];
+};
+type ChannelMessageSendMediaContext<TConfig = DaoCoreConfig> = ChannelMessageSendTextContext<TConfig> & {
+  mediaUrl: string;
+  mediaAccess?: OutboundMediaAccess;
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  audioAsVoice?: boolean;
+  gifPlayback?: boolean;
+  forceDocument?: boolean;
+};
+type ChannelMessageSendPayloadContext<TConfig = DaoCoreConfig> = ChannelMessageSendTextContext<TConfig> & {
+  payload: ReplyPayload;
+  mediaUrl?: string;
+  mediaAccess?: OutboundMediaAccess;
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  audioAsVoice?: boolean;
+  gifPlayback?: boolean;
+  forceDocument?: boolean;
+};
+type ChannelMessageSendPollContext<TConfig = DaoCoreConfig> = Omit<ChannelMessageSendTextContext<TConfig>, "text" | "threadId"> & {
+  poll: PollInput;
+  threadId?: string | null;
+  isAnonymous?: boolean;
+};
+type ChannelMessageSendResult = {
+  receipt: MessageReceipt;
+  messageId?: string;
+};
+type ChannelMessageSendAttemptKind = "text" | "media" | "payload" | "poll";
+type ChannelMessageSendAttemptContext<TConfig = DaoCoreConfig> = (ChannelMessageSendTextContext<TConfig> & {
+  kind: "text";
+}) | (ChannelMessageSendMediaContext<TConfig> & {
+  kind: "media";
+}) | (ChannelMessageSendPayloadContext<TConfig> & {
+  kind: "payload";
+}) | (ChannelMessageSendPollContext<TConfig> & {
+  kind: "poll";
+});
+type ChannelMessageSendSuccessContext<TConfig = DaoCoreConfig, TSendResult extends ChannelMessageSendResult = ChannelMessageSendResult> = ChannelMessageSendAttemptContext<TConfig> & {
+  result: TSendResult;
+  attemptToken?: unknown;
+};
+type ChannelMessageSendFailureContext<TConfig = DaoCoreConfig> = ChannelMessageSendAttemptContext<TConfig> & {
+  error: unknown;
+  attemptToken?: unknown;
+};
+type ChannelMessageSendCommitContext<TConfig = DaoCoreConfig, TSendResult extends ChannelMessageSendResult = ChannelMessageSendResult> = ChannelMessageSendSuccessContext<TConfig, TSendResult>;
+type ChannelMessageUnknownSendContext<TConfig = DaoCoreConfig> = {
+  cfg: TConfig;
+  queueId: string;
+  channel: string;
+  to: string;
+  accountId?: string | null;
+  enqueuedAt: number;
+  retryCount: number;
+  platformSendStartedAt?: number;
+  payloads: readonly ReplyPayload[];
+  renderedBatchPlan?: RenderedMessageBatchPlan;
+  replyToId?: string | null;
+  replyToMode?: ReplyToMode;
+  threadId?: string | number | null;
+  silent?: boolean;
+};
+type ChannelMessageUnknownSendReconciliationResult = {
+  status: "sent";
+  receipt: MessageReceipt;
+  messageId?: string;
+} | {
+  status: "not_sent";
+} | {
+  status: "unresolved";
+  error?: string;
+  retryable?: boolean;
+};
+type ChannelMessageSendLifecycleAdapter<TConfig = DaoCoreConfig, TSendResult extends ChannelMessageSendResult = ChannelMessageSendResult> = {
+  beforeSendAttempt?: (ctx: ChannelMessageSendAttemptContext<TConfig>) => unknown;
+  afterSendSuccess?: (ctx: ChannelMessageSendSuccessContext<TConfig, TSendResult>) => Promise<void> | void;
+  afterSendFailure?: (ctx: ChannelMessageSendFailureContext<TConfig>) => Promise<void> | void;
+  afterCommit?: (ctx: ChannelMessageSendCommitContext<TConfig, TSendResult>) => Promise<void> | void;
+};
+type ChannelMessageSendAdapter<TConfig = DaoCoreConfig, TSendResult extends ChannelMessageSendResult = ChannelMessageSendResult> = {
+  text?: (ctx: ChannelMessageSendTextContext<TConfig>) => Promise<TSendResult>;
+  media?: (ctx: ChannelMessageSendMediaContext<TConfig>) => Promise<TSendResult>;
+  payload?: (ctx: ChannelMessageSendPayloadContext<TConfig>) => Promise<TSendResult>;
+  poll?: (ctx: ChannelMessageSendPollContext<TConfig>) => Promise<TSendResult>;
+  lifecycle?: ChannelMessageSendLifecycleAdapter<TConfig, TSendResult>;
+};
+type ChannelMessageDurableFinalAdapter = {
+  capabilities?: DurableFinalDeliveryRequirementMap;
+  reconcileUnknownSend?: (ctx: ChannelMessageUnknownSendContext) => Promise<ChannelMessageUnknownSendReconciliationResult | null> | ChannelMessageUnknownSendReconciliationResult | null;
+};
+type ChannelMessageLiveCapability = "draftPreview" | "previewFinalization" | "progressUpdates" | "nativeStreaming" | "quietFinalization";
+declare const livePreviewFinalizerCapabilities: readonly ["finalEdit", "normalFallback", "discardPending", "previewReceipt", "retainOnAmbiguousFailure"];
+type LivePreviewFinalizerCapability = (typeof livePreviewFinalizerCapabilities)[number];
+type LivePreviewFinalizerCapabilityMap = Partial<Record<LivePreviewFinalizerCapability, boolean>>;
+type ChannelMessageLiveFinalizerAdapterShape = {
+  capabilities?: LivePreviewFinalizerCapabilityMap;
+};
+type ChannelMessageLiveAdapterShape = {
+  capabilities?: Partial<Record<ChannelMessageLiveCapability, boolean>>;
+  finalizer?: ChannelMessageLiveFinalizerAdapterShape;
+};
+type ChannelMessageReceiveAckPolicy = "after_receive_record" | "after_agent_dispatch" | "after_durable_send" | "manual";
+type ChannelMessageReceiveAdapterShape = {
+  defaultAckPolicy?: ChannelMessageReceiveAckPolicy;
+  supportedAckPolicies?: readonly ChannelMessageReceiveAckPolicy[];
+};
+type ChannelMessageAdapterShape<TConfig = DaoCoreConfig, TSendResult extends ChannelMessageSendResult = ChannelMessageSendResult> = {
+  id?: string;
+  durableFinal?: ChannelMessageDurableFinalAdapter;
+  send?: ChannelMessageSendAdapter<TConfig, TSendResult>;
+  live?: ChannelMessageLiveAdapterShape;
+  receive?: ChannelMessageReceiveAdapterShape;
+};
+type ChannelMessageAdapter<TAdapter extends ChannelMessageAdapterShape = ChannelMessageAdapterShape> = TAdapter;
+type DurableFinalRequirementExtras = DurableFinalDeliveryRequirementMap;
+type DeriveDurableFinalDeliveryRequirementsParams = {
+  payload: DurableFinalDeliveryPayloadShape;
+  replyToId?: string | null;
+  threadId?: string | number | null;
+  silent?: boolean;
+  messageSendingHooks?: boolean;
+  payloadTransport?: boolean;
+  batch?: boolean;
+  reconcileUnknownSend?: boolean;
+  afterSendSuccess?: boolean;
+  afterCommit?: boolean;
+  extraCapabilities?: DurableFinalRequirementExtras;
+};
+type DurableMessageSendIntent<TPayload = unknown> = {
+  id: string;
+  channel: string;
+  to: string;
+  accountId?: string;
+  durability: Exclude<MessageDurabilityPolicy, "disabled">;
+  renderedBatch?: RenderedMessageBatch<TPayload>;
+};
+//#endregion
+export { LiveMessageState as A, RenderedMessageBatchPlan as B, DeriveDurableFinalDeliveryRequirementsParams as C, DurableFinalRequirementExtras as D, DurableFinalDeliveryRequirementMap as E, MessageReceiptPart as F, RenderedMessageBatchPlanKind as H, MessageReceiptPartKind as I, MessageReceiptSourceResult as L, LivePreviewFinalizerCapabilityMap as M, MessageDurabilityPolicy as N, DurableMessageSendIntent as O, MessageReceipt as P, MessageSendContext as R, ChannelMessageUnknownSendReconciliationResult as S, DurableFinalDeliveryPayloadShape as T, RenderedMessageBatchPlanItem as V, ChannelMessageSendPollContext as _, ChannelMessageLiveCapability as a, ChannelMessageSendTextContext as b, ChannelMessageReceiveAdapterShape as c, ChannelMessageSendAttemptKind as d, ChannelMessageSendCommitContext as f, ChannelMessageSendPayloadContext as g, ChannelMessageSendMediaContext as h, ChannelMessageLiveAdapterShape as i, LivePreviewFinalizerCapability as j, LiveMessagePhase as k, ChannelMessageSendAdapter as l, ChannelMessageSendLifecycleAdapter as m, ChannelMessageAdapterShape as n, ChannelMessageLiveFinalizerAdapterShape as o, ChannelMessageSendFailureContext as p, ChannelMessageDurableFinalAdapter as r, ChannelMessageReceiveAckPolicy as s, ChannelMessageAdapter as t, ChannelMessageSendAttemptContext as u, ChannelMessageSendResult as v, DurableFinalDeliveryCapability as w, ChannelMessageUnknownSendContext as x, ChannelMessageSendSuccessContext as y, RenderedMessageBatch as z };

package/dist/types-Cp7p0rkN.d.ts

@@ -0,0 +1,107 @@
+import { K as PromptImageOrderEntry, a as SourceReplyDeliveryMode } from "./get-reply-options.types-BXrapyJ-.js";
+import { d as ExecElevatedDefaults, i as PromptMode, l as AgentStreamParams, s as AgentInternalEvent, u as ClientToolDefinition } from "./params-Bpqaub6s.js";
+import { t as InputProvenance } from "./input-provenance-DgsxhTbk.js";
+import { O as ChannelOutboundTargetMode } from "./types.core-tk4nkbSB.js";
+//#region src/agents/spawned-context.d.ts
+type SpawnedRunMetadata = {
+  spawnedBy?: string | null;
+  groupId?: string | null;
+  groupChannel?: string | null;
+  groupSpace?: string | null;
+  workspaceDir?: string | null;
+};
+//#endregion
+//#region src/agents/command/types.d.ts
+/** Image content block for Claude API multimodal messages. */
+type ImageContent = {
+  type: "image";
+  data: string;
+  mimeType: string;
+};
+type AgentCommandResultMetaOverrides = {
+  transport?: "embedded";
+  fallbackFrom?: "gateway";
+  fallbackReason?: "gateway_timeout";
+  fallbackSessionId?: string;
+  fallbackSessionKey?: string;
+};
+type AcpTurnSource = "manual_spawn";
+type AgentRunContext = {
+  messageChannel?: string;
+  accountId?: string;
+  groupId?: string | null;
+  groupChannel?: string | null;
+  groupSpace?: string | null;
+  currentChannelId?: string;
+  currentThreadTs?: string;
+  replyToMode?: "off" | "first" | "all" | "batched";
+  hasRepliedRef?: {
+    value: boolean;
+  };
+};
+type AgentCommandOpts = {
+  message: string; /** User-visible transcript body; defaults to message and excludes runtime-only context. */
+  transcriptMessage?: string; /** Optional image attachments for multimodal messages. */
+  images?: ImageContent[]; /** Original inline/offloaded attachment order for inbound images. */
+  imageOrder?: PromptImageOrderEntry[]; /** Optional client-provided tools (OpenResponses hosted tools). */
+  clientTools?: ClientToolDefinition[]; /** Agent id override (must exist in config). */
+  agentId?: string; /** Per-run provider override. */
+  provider?: string; /** Per-run model override. */
+  model?: string;
+  to?: string;
+  sessionId?: string;
+  sessionKey?: string;
+  thinking?: string;
+  thinkingOnce?: string;
+  verbose?: string;
+  json?: boolean;
+  timeout?: string;
+  deliver?: boolean; /** Override delivery target (separate from session routing). */
+  replyTo?: string; /** Override delivery channel (separate from session routing). */
+  replyChannel?: string; /** Override delivery account id (separate from session routing). */
+  replyAccountId?: string; /** Override delivery thread/topic id (separate from session routing). */
+  threadId?: string | number; /** Message channel context. */
+  messageChannel?: string; /** Tool-policy/output surface context. Defaults to messageChannel. */
+  messageProvider?: string; /** Delivery channel. */
+  channel?: string; /** Account ID for multi-account channel routing. */
+  accountId?: string; /** Context for embedded run routing (channel/account/thread). */
+  runContext?: AgentRunContext; /** Internal trusted exec approval follow-up elevated defaults. */
+  bashElevated?: ExecElevatedDefaults; /** Trusted sender identity bit for command/channel-action auth; defaults true for local CLI calls. */
+  senderIsOwner?: boolean; /** Whether this caller is authorized to use provider/model per-run overrides. */
+  allowModelOverride?: boolean; /** Optional runtime tool allow-list; when set, only these tools are exposed for this run. */
+  toolsAllow?: string[]; /** Group/spawn metadata for subagent policy inheritance and routing context. */
+  groupId?: SpawnedRunMetadata["groupId"];
+  groupChannel?: SpawnedRunMetadata["groupChannel"];
+  groupSpace?: SpawnedRunMetadata["groupSpace"];
+  spawnedBy?: SpawnedRunMetadata["spawnedBy"];
+  deliveryTargetMode?: ChannelOutboundTargetMode;
+  bestEffortDeliver?: boolean;
+  abortSignal?: AbortSignal;
+  lane?: string;
+  runId?: string;
+  extraSystemPrompt?: string; /** Bootstrap workspace context injection mode for this run. */
+  bootstrapContextMode?: "full" | "lightweight"; /** Run kind hint for bootstrap context behavior. */
+  bootstrapContextRunKind?: "default" | "heartbeat" | "cron";
+  internalEvents?: AgentInternalEvent[];
+  inputProvenance?: InputProvenance; /** Visible source replies must be sent through the message tool when set. */
+  sourceReplyDeliveryMode?: SourceReplyDeliveryMode; /** Per-call stream param overrides (best-effort). */
+  streamParams?: AgentStreamParams; /** Explicit workspace directory override (for subagents to inherit parent workspace). */
+  workspaceDir?: SpawnedRunMetadata["workspaceDir"]; /** Force bundled MCP teardown when a one-shot local run completes. */
+  cleanupBundleMcpOnRunEnd?: boolean; /** Force long-lived CLI live session teardown when a one-shot local run completes. */
+  cleanupCliLiveSessionOnRunEnd?: boolean; /** Internal local CLI callers can annotate result metadata before JSON/text output. */
+  resultMetaOverrides?: AgentCommandResultMetaOverrides; /** Called when the actual run model is selected, including fallback retries. */
+  onActiveModelSelected?: (ctx: {
+    provider: string;
+    model: string;
+  }) => void; /** Internal one-shot model probe mode: no tools, no workspace/chat prompt policy. */
+  modelRun?: boolean; /** Internal prompt-mode override for trusted local/gateway callsites. */
+  promptMode?: PromptMode; /** Internal ACP-ready session turn source. Manual spawn turns bypass only the dispatch gate. */
+  acpTurnSource?: AcpTurnSource; /** Internal handoffs can feed the model without writing the synthetic prompt to transcript. */
+  suppressPromptPersistence?: boolean;
+};
+type AgentCommandIngressOpts = Omit<AgentCommandOpts, "senderIsOwner" | "allowModelOverride" | "resultMetaOverrides"> & {
+  /** Trusted sender identity bit for command/channel-action auth; defaults false for ingress. */senderIsOwner?: boolean; /** Ingress callsites must always pass explicit model-override authorization state. */
+  allowModelOverride: boolean;
+};
+//#endregion
+export { AgentCommandOpts as n, AgentCommandResultMetaOverrides as r, AgentCommandIngressOpts as t };

package/dist/types-DCT-w72n.d.ts

@@ -0,0 +1,97 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { p as SecretRef } from "./types.secrets-tbFW-hY6.js";
+
+//#region src/agents/auth-profiles/types.d.ts
+type OAuthProvider = string;
+type OAuthCredentials = {
+  access: string;
+  refresh: string;
+  expires: number;
+  provider?: OAuthProvider;
+  email?: string;
+  enterpriseUrl?: string;
+  projectId?: string;
+  accountId?: string;
+  chatgptPlanType?: string;
+  idToken?: string;
+};
+type ApiKeyCredential = {
+  type: "api_key";
+  provider: string;
+  key?: string;
+  keyRef?: SecretRef; /** Explicit opt-out for copying this profile when creating another agent. */
+  copyToAgents?: boolean;
+  email?: string;
+  displayName?: string; /** Optional provider-specific metadata (e.g., account IDs, gateway IDs). */
+  metadata?: Record<string, string>;
+};
+type TokenCredential = {
+  /**
+   * Static bearer-style token (often OAuth access token / PAT).
+   * Not refreshable by DaoCore (unlike `type: "oauth"`).
+   */
+  type: "token";
+  provider: string;
+  token?: string;
+  tokenRef?: SecretRef; /** Explicit opt-out for copying this profile when creating another agent. */
+  copyToAgents?: boolean; /** Optional expiry timestamp (ms since epoch). */
+  expires?: number;
+  email?: string;
+  displayName?: string;
+};
+type OAuthCredential = OAuthCredentials & {
+  type: "oauth";
+  provider: string;
+  clientId?: string;
+  /**
+   * OAuth refresh tokens are not portable by default. Provider-owned flows may
+   * set this only when copying refresh material across agents is known safe.
+   */
+  copyToAgents?: boolean;
+  email?: string;
+  displayName?: string;
+};
+type AuthProfileCredential = ApiKeyCredential | TokenCredential | OAuthCredential;
+type AuthProfileFailureReason = "auth" | "auth_permanent" | "format" | "overloaded" | "rate_limit" | "billing" | "timeout" | "model_not_found" | "session_expired" | "empty_response" | "no_error_details" | "unclassified" | "unknown";
+type AuthProfileBlockedReason = "subscription_limit";
+type AuthProfileBlockedSource = "codex_rate_limits" | "wham";
+/** Per-profile usage statistics for round-robin and cooldown tracking */
+type ProfileUsageStats = {
+  lastUsed?: number;
+  blockedUntil?: number;
+  blockedReason?: AuthProfileBlockedReason;
+  blockedSource?: AuthProfileBlockedSource;
+  blockedModel?: string;
+  cooldownUntil?: number;
+  cooldownReason?: AuthProfileFailureReason;
+  cooldownModel?: string;
+  disabledUntil?: number;
+  disabledReason?: AuthProfileFailureReason;
+  errorCount?: number;
+  failureCounts?: Partial<Record<AuthProfileFailureReason, number>>;
+  lastFailureAt?: number;
+};
+type AuthProfileState = {
+  /**
+   * Optional per-agent preferred profile order overrides.
+   * This lets you lock/override auth rotation for a specific agent without
+   * changing the global config.
+   */
+  order?: Record<string, string[]>;
+  lastGood?: Record<string, string>; /** Usage statistics per profile for round-robin rotation */
+  usageStats?: Record<string, ProfileUsageStats>;
+};
+type AuthProfileSecretsStore = {
+  version: number;
+  profiles: Record<string, AuthProfileCredential>;
+};
+type AuthProfileStore = AuthProfileSecretsStore & AuthProfileState;
+type AuthProfileIdRepairResult = {
+  config: DaoCoreConfig;
+  changes: string[];
+  migrated: boolean;
+  fromProfileId?: string;
+  toProfileId?: string;
+};
+//#endregion
+export { AuthProfileFailureReason as a, OAuthCredential as c, TokenCredential as d, AuthProfileCredential as i, OAuthProvider as l, AuthProfileBlockedReason as n, AuthProfileIdRepairResult as o, AuthProfileBlockedSource as r, AuthProfileStore as s, ApiKeyCredential as t, ProfileUsageStats as u };