@gaodefa/daocore 2026.5.69 → 2026.5.70

package/dist/channel-pairing-BRqfYy30.d.ts

@@ -0,0 +1,58 @@
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { t as ChannelPairingAdapter } from "./pairing.types-CQONFSHw.js";
+import { n as PluginRuntime } from "./types-CqkHo5uy.js";
+import { n as issuePairingChallenge } from "./pairing-challenge-DD0D0sfM.js";
+
+//#region src/channels/plugins/pairing-adapters.d.ts
+type PairingNotifyParams = Parameters<NonNullable<ChannelPairingAdapter["notifyApproval"]>>[0];
+declare function createPairingPrefixStripper(prefixRe: RegExp, map?: (entry: string) => string): NonNullable<ChannelPairingAdapter["normalizeAllowEntry"]>;
+declare function createLoggedPairingApprovalNotifier(format: string | ((params: PairingNotifyParams) => string), log?: (message: string) => void): NonNullable<ChannelPairingAdapter["notifyApproval"]>;
+declare function createTextPairingAdapter(params: {
+  idLabel: string;
+  message: string;
+  normalizeAllowEntry?: ChannelPairingAdapter["normalizeAllowEntry"];
+  notify: (params: PairingNotifyParams & {
+    message: string;
+  }) => Promise<void> | void;
+}): ChannelPairingAdapter;
+//#endregion
+//#region src/plugin-sdk/pairing-access.d.ts
+type PairingApi = PluginRuntime["channel"]["pairing"];
+type ScopedUpsertInput = Omit<Parameters<PairingApi["upsertPairingRequest"]>[0], "channel" | "accountId">;
+/** Scope pairing store operations to one channel/account pair for plugin-facing helpers. */
+declare function createScopedPairingAccess(params: {
+  core: PluginRuntime;
+  channel: ChannelId;
+  accountId: string;
+}): {
+  accountId: string;
+  readAllowFromStore: () => Promise<string[]>;
+  readStoreForDmPolicy: (provider: ChannelId, accountId: string) => Promise<string[]>;
+  upsertPairingRequest: (input: ScopedUpsertInput) => Promise<{
+    code: string;
+    created: boolean;
+  }>;
+};
+//#endregion
+//#region src/plugin-sdk/channel-pairing.d.ts
+type ScopedPairingAccess = ReturnType<typeof createScopedPairingAccess>;
+/** Pairing helpers scoped to one channel account. */
+type ChannelPairingController = ScopedPairingAccess & {
+  issueChallenge: (params: Omit<Parameters<typeof issuePairingChallenge>[0], "channel" | "upsertPairingRequest">) => ReturnType<typeof issuePairingChallenge>;
+};
+/** Pre-bind the channel id and storage sink for pairing challenges. */
+declare function createChannelPairingChallengeIssuer(params: {
+  channel: ChannelId;
+  upsertPairingRequest: Parameters<typeof issuePairingChallenge>[0]["upsertPairingRequest"];
+}): (challenge: Omit<Parameters<typeof issuePairingChallenge>[0], "channel" | "upsertPairingRequest">) => Promise<{
+  created: boolean;
+  code?: string;
+}>;
+/** Build the full scoped pairing controller used by channel runtime code. */
+declare function createChannelPairingController(params: {
+  core: PluginRuntime;
+  channel: ChannelId;
+  accountId: string;
+}): ChannelPairingController;
+//#endregion
+export { createPairingPrefixStripper as a, createLoggedPairingApprovalNotifier as i, createChannelPairingChallengeIssuer as n, createTextPairingAdapter as o, createChannelPairingController as r, ChannelPairingController as t };

package/dist/channel-plugin-common-DoggLmA6.d.ts

@@ -0,0 +1,9 @@
+import { n as ChatChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { E as ChannelMeta } from "./types.core-DpVp9PoP.js";
+//#region src/channels/chat-meta-shared.d.ts
+type ChatChannelMeta = ChannelMeta;
+//#endregion
+//#region src/channels/chat-meta.d.ts
+declare function getChatChannelMeta(id: ChatChannelId): ChatChannelMeta;
+//#endregion
+export { getChatChannelMeta as t };

package/dist/channel-plugin-runtime-Bl5UlXSV.d.ts

@@ -0,0 +1,7 @@
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+import { t as ResolvedMattermostAccount } from "./accounts-Deymhmce.js";
+
+//#region extensions/mattermost/src/channel.d.ts
+declare const mattermostPlugin: ChannelPlugin<ResolvedMattermostAccount>;
+//#endregion
+export { mattermostPlugin as t };

package/dist/channel-policy-BAVTkvbT.d.ts

@@ -0,0 +1,198 @@
+import { r as DaoCoreConfig } from "./types.daocore-kp8IyikH.js";
+import { _ as GroupPolicy } from "./types.base-tQh4FMBR.js";
+import { V as ChannelSecurityAdapter } from "./types.adapters-StiSC8e-.js";
+//#region src/channels/plugins/group-policy-warnings.d.ts
+type GroupPolicyWarningCollector = (groupPolicy: GroupPolicy) => string[];
+type AccountGroupPolicyWarningCollector<ResolvedAccount> = (params: {
+  account: ResolvedAccount;
+  cfg: DaoCoreConfig;
+}) => string[];
+type ConfigGroupPolicyWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+}> = (params: Params) => string[];
+type WarningCollector<Params> = (params: Params) => string[];
+declare function composeWarningCollectors<Params>(...collectors: Array<WarningCollector<Params> | null | undefined>): WarningCollector<Params>;
+declare function projectWarningCollector<Params, Projected>(project: (params: Params) => Projected, collector: WarningCollector<Projected>): WarningCollector<Params>;
+declare function projectConfigWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+}>(collector: WarningCollector<{
+  cfg: DaoCoreConfig;
+}>): WarningCollector<Params>;
+declare function projectConfigAccountIdWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}>(collector: WarningCollector<{
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}>): WarningCollector<Params>;
+declare function projectAccountWarningCollector<ResolvedAccount, Params extends {
+  account: ResolvedAccount;
+}>(collector: WarningCollector<ResolvedAccount>): WarningCollector<Params>;
+declare function projectAccountConfigWarningCollector<ResolvedAccount, ProjectedCfg, Params extends {
+  account: ResolvedAccount;
+  cfg: DaoCoreConfig;
+}>(projectCfg: (cfg: DaoCoreConfig) => ProjectedCfg, collector: WarningCollector<{
+  account: ResolvedAccount;
+  cfg: ProjectedCfg;
+}>): WarningCollector<Params>;
+declare function createConditionalWarningCollector<Params>(...collectors: Array<(params: Params) => string | string[] | null | undefined | false>): WarningCollector<Params>;
+declare function composeAccountWarningCollectors<ResolvedAccount, Params extends {
+  account: ResolvedAccount;
+}>(baseCollector: WarningCollector<Params>, ...collectors: Array<(account: ResolvedAccount) => string | string[] | null | undefined | false>): WarningCollector<Params>;
+declare function buildOpenGroupPolicyWarning(params: {
+  surface: string;
+  openBehavior: string;
+  remediation: string;
+}): string;
+declare function buildOpenGroupPolicyRestrictSendersWarning(params: {
+  surface: string;
+  openScope: string;
+  groupPolicyPath: string;
+  groupAllowFromPath: string;
+  mentionGated?: boolean;
+}): string;
+declare function buildOpenGroupPolicyNoRouteAllowlistWarning(params: {
+  surface: string;
+  routeAllowlistPath: string;
+  routeScope: string;
+  groupPolicyPath: string;
+  groupAllowFromPath: string;
+  mentionGated?: boolean;
+}): string;
+declare function buildOpenGroupPolicyConfigureRouteAllowlistWarning(params: {
+  surface: string;
+  openScope: string;
+  groupPolicyPath: string;
+  routeAllowlistPath: string;
+  mentionGated?: boolean;
+}): string;
+declare function collectOpenGroupPolicyRestrictSendersWarnings(params: Parameters<typeof buildOpenGroupPolicyRestrictSendersWarning>[0] & {
+  groupPolicy: "open" | "allowlist" | "disabled";
+}): string[];
+declare function collectAllowlistProviderRestrictSendersWarnings(params: {
+  cfg: DaoCoreConfig;
+  providerConfigPresent: boolean;
+  configuredGroupPolicy?: GroupPolicy | null;
+} & Omit<Parameters<typeof collectOpenGroupPolicyRestrictSendersWarnings>[0], "groupPolicy">): string[];
+/** Build an account-aware allowlist-provider warning collector for sender-restricted groups. */
+declare function createAllowlistProviderRestrictSendersWarningCollector<ResolvedAccount>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+} & Omit<Parameters<typeof collectAllowlistProviderRestrictSendersWarnings>[0], "cfg" | "providerConfigPresent" | "configuredGroupPolicy">): AccountGroupPolicyWarningCollector<ResolvedAccount>;
+/** Build a direct account-aware warning collector when the policy already lives on the account. */
+declare function createOpenGroupPolicyRestrictSendersWarningCollector<ResolvedAccount>(params: {
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  defaultGroupPolicy?: GroupPolicy;
+} & Omit<Parameters<typeof collectOpenGroupPolicyRestrictSendersWarnings>[0], "groupPolicy">): (account: ResolvedAccount) => string[];
+declare function collectAllowlistProviderGroupPolicyWarnings(params: {
+  cfg: DaoCoreConfig;
+  providerConfigPresent: boolean;
+  configuredGroupPolicy?: GroupPolicy | null;
+  collect: GroupPolicyWarningCollector;
+}): string[];
+/** Build a config-aware allowlist-provider warning collector from an arbitrary policy resolver. */
+declare function createAllowlistProviderGroupPolicyWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+}>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (params: Params) => GroupPolicy | null | undefined;
+  collect: (params: Params & {
+    groupPolicy: GroupPolicy;
+  }) => string[];
+}): ConfigGroupPolicyWarningCollector<Params>;
+declare function collectOpenProviderGroupPolicyWarnings(params: {
+  cfg: DaoCoreConfig;
+  providerConfigPresent: boolean;
+  configuredGroupPolicy?: GroupPolicy | null;
+  collect: GroupPolicyWarningCollector;
+}): string[];
+/** Build a config-aware open-provider warning collector from an arbitrary policy resolver. */
+declare function createOpenProviderGroupPolicyWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+}>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (params: Params) => GroupPolicy | null | undefined;
+  collect: (params: Params & {
+    groupPolicy: GroupPolicy;
+  }) => string[];
+}): ConfigGroupPolicyWarningCollector<Params>;
+/** Build an account-aware allowlist-provider warning collector for simple open-policy warnings. */
+declare function createAllowlistProviderOpenWarningCollector<ResolvedAccount>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  buildOpenWarning: Parameters<typeof buildOpenGroupPolicyWarning>[0];
+}): AccountGroupPolicyWarningCollector<ResolvedAccount>;
+declare function collectOpenGroupPolicyRouteAllowlistWarnings(params: {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  routeAllowlistConfigured: boolean;
+  restrictSenders: Parameters<typeof buildOpenGroupPolicyRestrictSendersWarning>[0];
+  noRouteAllowlist: Parameters<typeof buildOpenGroupPolicyNoRouteAllowlistWarning>[0];
+}): string[];
+/** Build an account-aware allowlist-provider warning collector for route-allowlisted groups. */
+declare function createAllowlistProviderRouteAllowlistWarningCollector<ResolvedAccount>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  resolveRouteAllowlistConfigured: (account: ResolvedAccount) => boolean;
+  restrictSenders: Parameters<typeof buildOpenGroupPolicyRestrictSendersWarning>[0];
+  noRouteAllowlist: Parameters<typeof buildOpenGroupPolicyNoRouteAllowlistWarning>[0];
+}): AccountGroupPolicyWarningCollector<ResolvedAccount>;
+declare function collectOpenGroupPolicyConfiguredRouteWarnings(params: {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  routeAllowlistConfigured: boolean;
+  configureRouteAllowlist: Parameters<typeof buildOpenGroupPolicyConfigureRouteAllowlistWarning>[0];
+  missingRouteAllowlist: Parameters<typeof buildOpenGroupPolicyWarning>[0];
+}): string[];
+/** Build an account-aware open-provider warning collector for configured-route channels. */
+declare function createOpenProviderConfiguredRouteWarningCollector<ResolvedAccount>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  resolveRouteAllowlistConfigured: (account: ResolvedAccount) => boolean;
+  configureRouteAllowlist: Parameters<typeof buildOpenGroupPolicyConfigureRouteAllowlistWarning>[0];
+  missingRouteAllowlist: Parameters<typeof buildOpenGroupPolicyWarning>[0];
+}): AccountGroupPolicyWarningCollector<ResolvedAccount>;
+//#endregion
+//#region src/plugin-sdk/channel-policy.d.ts
+declare function normalizeAllowFromList(list: Array<string | number> | undefined | null): string[];
+declare function coerceNativeSetting(value: unknown): boolean | "auto" | undefined;
+type ChannelMutableAllowlistCandidate = {
+  pathLabel: string;
+  list: unknown;
+};
+declare function createDangerousNameMatchingMutableAllowlistWarningCollector(params: {
+  channel: string;
+  detector: (entry: string) => boolean;
+  collectLists: (scope: {
+    prefix: string;
+    account: Record<string, unknown>;
+    dangerousFlagPath: string;
+  }) => ChannelMutableAllowlistCandidate[];
+}): ({
+  cfg
+}: {
+  cfg: DaoCoreConfig;
+}) => string[];
+/** Compose the common DM policy resolver with restrict-senders group warnings. */
+declare function createRestrictSendersChannelSecurity<ResolvedAccount extends {
+  accountId?: string | null;
+}>(params: {
+  channelKey: string;
+  resolveDmPolicy: (account: ResolvedAccount) => string | null | undefined;
+  resolveDmAllowFrom: (account: ResolvedAccount) => Array<string | number> | null | undefined;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  surface: string;
+  openScope: string;
+  groupPolicyPath: string;
+  groupAllowFromPath: string;
+  mentionGated?: boolean;
+  providerConfigPresent?: (cfg: DaoCoreConfig) => boolean;
+  resolveFallbackAccountId?: (account: ResolvedAccount) => string | null | undefined;
+  defaultDmPolicy?: string;
+  allowFromPathSuffix?: string;
+  policyPathSuffix?: string;
+  approveChannelId?: string;
+  approveHint?: string;
+  normalizeDmEntry?: (raw: string) => string;
+  inheritSharedDefaultsFromDefaultAccount?: boolean;
+}): ChannelSecurityAdapter<ResolvedAccount>;
+//#endregion
+export { createOpenProviderConfiguredRouteWarningCollector as C, projectConfigAccountIdWarningCollector as D, projectAccountWarningCollector as E, projectConfigWarningCollector as O, createOpenGroupPolicyRestrictSendersWarningCollector as S, projectAccountConfigWarningCollector as T, createAllowlistProviderGroupPolicyWarningCollector as _, normalizeAllowFromList as a, createAllowlistProviderRouteAllowlistWarningCollector as b, buildOpenGroupPolicyWarning as c, collectOpenGroupPolicyConfiguredRouteWarnings as d, collectOpenGroupPolicyRestrictSendersWarnings as f, composeWarningCollectors as g, composeAccountWarningCollectors as h, createRestrictSendersChannelSecurity as i, projectWarningCollector as k, collectAllowlistProviderGroupPolicyWarnings as l, collectOpenProviderGroupPolicyWarnings as m, coerceNativeSetting as n, buildOpenGroupPolicyConfigureRouteAllowlistWarning as o, collectOpenGroupPolicyRouteAllowlistWarnings as p, createDangerousNameMatchingMutableAllowlistWarningCollector as r, buildOpenGroupPolicyRestrictSendersWarning as s, ChannelMutableAllowlistCandidate as t, collectAllowlistProviderRestrictSendersWarnings as u, createAllowlistProviderOpenWarningCollector as v, createOpenProviderGroupPolicyWarningCollector as w, createConditionalWarningCollector as x, createAllowlistProviderRestrictSendersWarningCollector as y };

package/dist/channel-secret-basic-runtime-5Xvr458K.d.ts

@@ -0,0 +1,65 @@
+import { r as SecretDefaults, t as ResolverContext } from "./runtime-shared-Dey36NLs.js";
+
+//#region src/secrets/channel-secret-basic-runtime.d.ts
+type ChannelAccountEntry = {
+  accountId: string;
+  account: Record<string, unknown>;
+  enabled: boolean;
+};
+type ChannelAccountSurface = {
+  hasExplicitAccounts: boolean;
+  channelEnabled: boolean;
+  accounts: ChannelAccountEntry[];
+};
+type ChannelAccountPredicate = (entry: ChannelAccountEntry) => boolean;
+declare function getChannelRecord(config: {
+  channels?: Record<string, unknown>;
+}, channelKey: string): Record<string, unknown> | undefined;
+declare function getChannelSurface(config: {
+  channels?: Record<string, unknown>;
+}, channelKey: string): {
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+} | null;
+declare function resolveChannelAccountSurface(channel: Record<string, unknown>): ChannelAccountSurface;
+declare function isBaseFieldActiveForChannelSurface(surface: ChannelAccountSurface, rootKey: string): boolean;
+declare function normalizeSecretStringValue(value: unknown): string;
+declare function hasConfiguredSecretInputValue(value: unknown, defaults: SecretDefaults | undefined): boolean;
+declare function collectSimpleChannelFieldAssignments(params: {
+  channelKey: string;
+  field: string;
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+  defaults: SecretDefaults | undefined;
+  context: ResolverContext;
+  topInactiveReason: string;
+  accountInactiveReason: string;
+}): void;
+declare function collectConditionalChannelFieldAssignments(params: {
+  channelKey: string;
+  field: string;
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+  defaults: SecretDefaults | undefined;
+  context: ResolverContext;
+  topLevelActiveWithoutAccounts: boolean;
+  topLevelInheritedAccountActive: ChannelAccountPredicate;
+  accountActive: ChannelAccountPredicate;
+  topInactiveReason: string;
+  accountInactiveReason: string | ((entry: ChannelAccountEntry) => string);
+}): void;
+declare function collectNestedChannelFieldAssignments(params: {
+  channelKey: string;
+  nestedKey: string;
+  field: string;
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+  defaults: SecretDefaults | undefined;
+  context: ResolverContext;
+  topLevelActive: boolean;
+  topInactiveReason: string;
+  accountActive: ChannelAccountPredicate;
+  accountInactiveReason: string | ((entry: ChannelAccountEntry) => string);
+}): void;
+//#endregion
+export { collectNestedChannelFieldAssignments as a, getChannelSurface as c, normalizeSecretStringValue as d, resolveChannelAccountSurface as f, collectConditionalChannelFieldAssignments as i, hasConfiguredSecretInputValue as l, ChannelAccountPredicate as n, collectSimpleChannelFieldAssignments as o, ChannelAccountSurface as r, getChannelRecord as s, ChannelAccountEntry as t, isBaseFieldActiveForChannelSurface as u };

package/dist/channel-secret-tts-runtime-CUyHELxV.d.ts

@@ -0,0 +1,22 @@
+import { r as SecretDefaults, t as ResolverContext } from "./runtime-shared-Dey36NLs.js";
+import { n as ChannelAccountPredicate, r as ChannelAccountSurface } from "./channel-secret-basic-runtime-5Xvr458K.js";
+
+//#region src/secrets/channel-secret-tts-runtime.d.ts
+declare function collectNestedChannelTtsAssignments(params: {
+  channelKey: string;
+  nestedKey: string;
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+  defaults: SecretDefaults | undefined;
+  context: ResolverContext;
+  topLevelActive: boolean;
+  topInactiveReason: string;
+  accountActive: ChannelAccountPredicate;
+  accountInactiveReason: string | ((entry: {
+    accountId: string;
+    account: Record<string, unknown>;
+    enabled: boolean;
+  }) => string);
+}): void;
+//#endregion
+export { collectNestedChannelTtsAssignments as t };

package/dist/channel-send-result-CVl4yjhQ.d.ts

@@ -0,0 +1,41 @@
+import { b as OutboundDeliveryResult, n as ChannelOutboundAdapter } from "./outbound.types-B2wXms-j.js";
+import { A as ChannelPollResult } from "./types.core-DpVp9PoP.js";
+//#region src/plugin-sdk/channel-send-result.d.ts
+type ChannelSendRawResult = {
+  ok: boolean;
+  messageId?: string | null;
+  error?: string | null;
+};
+declare function attachChannelToResult<T extends object>(channel: string, result: T): {
+  channel: string;
+} & T;
+declare function attachChannelToResults<T extends object>(channel: string, results: readonly T[]): ({
+  channel: string;
+} & T)[];
+declare function createEmptyChannelResult(channel: string, result?: Partial<Omit<OutboundDeliveryResult, "channel" | "messageId">> & {
+  messageId?: string;
+}): OutboundDeliveryResult;
+type MaybePromise<T> = T | Promise<T>;
+type SendTextParams = Parameters<NonNullable<ChannelOutboundAdapter["sendText"]>>[0];
+type SendMediaParams = Parameters<NonNullable<ChannelOutboundAdapter["sendMedia"]>>[0];
+type SendPollParams = Parameters<NonNullable<ChannelOutboundAdapter["sendPoll"]>>[0];
+declare function createAttachedChannelResultAdapter(params: {
+  channel: string;
+  sendText?: (ctx: SendTextParams) => MaybePromise<Omit<OutboundDeliveryResult, "channel">>;
+  sendMedia?: (ctx: SendMediaParams) => MaybePromise<Omit<OutboundDeliveryResult, "channel">>;
+  sendPoll?: (ctx: SendPollParams) => MaybePromise<Omit<ChannelPollResult, "channel">>;
+}): Pick<ChannelOutboundAdapter, "sendText" | "sendMedia" | "sendPoll">;
+declare function createRawChannelSendResultAdapter(params: {
+  channel: string;
+  sendText?: (ctx: SendTextParams) => MaybePromise<ChannelSendRawResult>;
+  sendMedia?: (ctx: SendMediaParams) => MaybePromise<ChannelSendRawResult>;
+}): Pick<ChannelOutboundAdapter, "sendText" | "sendMedia">;
+/** Normalize raw channel send results into the shape shared outbound callers expect. */
+declare function buildChannelSendResult(channel: string, result: ChannelSendRawResult): {
+  channel: string;
+  ok: boolean;
+  messageId: string;
+  error: Error | undefined;
+};
+//#endregion
+export { createAttachedChannelResultAdapter as a, buildChannelSendResult as i, attachChannelToResult as n, createEmptyChannelResult as o, attachChannelToResults as r, createRawChannelSendResultAdapter as s, ChannelSendRawResult as t };

package/dist/channel-setup-DTi7wNZI.d.ts

@@ -0,0 +1,29 @@
+import { s as ChannelSetupWizard } from "./setup-wizard-types-CDmi5gLx.js";
+import { H as ChannelSetupAdapter } from "./types.adapters-StiSC8e-.js";
+//#region src/plugin-sdk/optional-channel-setup.d.ts
+type OptionalChannelSetupParams$1 = {
+  channel: string;
+  label: string;
+  npmSpec?: string;
+  docsPath?: string;
+};
+declare function createOptionalChannelSetupAdapter(params: OptionalChannelSetupParams$1): ChannelSetupAdapter;
+declare function createOptionalChannelSetupWizard(params: OptionalChannelSetupParams$1): ChannelSetupWizard;
+//#endregion
+//#region src/plugin-sdk/channel-setup.d.ts
+/** Metadata used to advertise an optional channel plugin during setup flows. */
+type OptionalChannelSetupParams = {
+  channel: string;
+  label: string;
+  npmSpec?: string;
+  docsPath?: string;
+};
+/** Paired setup adapter + setup wizard for channels that may not be installed yet. */
+type OptionalChannelSetupSurface = {
+  setupAdapter: ChannelSetupAdapter;
+  setupWizard: ChannelSetupWizard;
+};
+/** Build both optional setup surfaces from one metadata object. */
+declare function createOptionalChannelSetupSurface(params: OptionalChannelSetupParams): OptionalChannelSetupSurface;
+//#endregion
+export { createOptionalChannelSetupWizard as i, createOptionalChannelSetupSurface as n, createOptionalChannelSetupAdapter as r, OptionalChannelSetupSurface as t };

package/dist/channel-status-BbO3pbi9.d.ts

@@ -0,0 +1,9 @@
+import { r as ChannelAccountSnapshot } from "./types.core-DpVp9PoP.js";
+//#region src/channels/account-snapshot-fields.d.ts
+declare const CREDENTIAL_STATUS_KEYS: readonly ["tokenStatus", "botTokenStatus", "appTokenStatus", "signingSecretStatus", "userTokenStatus"];
+type CredentialStatusKey = (typeof CREDENTIAL_STATUS_KEYS)[number];
+declare function resolveConfiguredFromCredentialStatuses(account: unknown): boolean | undefined;
+declare function resolveConfiguredFromRequiredCredentialStatuses(account: unknown, requiredKeys: CredentialStatusKey[]): boolean | undefined;
+declare function projectCredentialSnapshotFields(account: unknown): Pick<Partial<ChannelAccountSnapshot>, "tokenSource" | "botTokenSource" | "appTokenSource" | "signingSecretSource" | "tokenStatus" | "botTokenStatus" | "appTokenStatus" | "signingSecretStatus" | "userTokenStatus">;
+//#endregion
+export { resolveConfiguredFromCredentialStatuses as n, resolveConfiguredFromRequiredCredentialStatuses as r, projectCredentialSnapshotFields as t };

package/dist/channel-targets-nXN3IwqM.d.ts

@@ -0,0 +1,94 @@
+import { H as ChannelTtsVoiceDeliveryCapabilities } from "./types.core-DpVp9PoP.js";
+//#region src/channels/plugins/chat-target-prefixes.d.ts
+type ServicePrefix<TService extends string> = {
+  prefix: string;
+  service: TService;
+};
+type ChatTargetPrefixesParams = {
+  trimmed: string;
+  lower: string;
+  chatIdPrefixes: string[];
+  chatGuidPrefixes: string[];
+  chatIdentifierPrefixes: string[];
+};
+type ParsedChatTarget = {
+  kind: "chat_id";
+  chatId: number;
+} | {
+  kind: "chat_guid";
+  chatGuid: string;
+} | {
+  kind: "chat_identifier";
+  chatIdentifier: string;
+};
+type ParsedChatAllowTarget = ParsedChatTarget | {
+  kind: "handle";
+  handle: string;
+};
+type ChatSenderAllowParams = {
+  allowFrom: Array<string | number>;
+  sender: string;
+  chatId?: number | null;
+  chatGuid?: string | null;
+  chatIdentifier?: string | null;
+  allowConversationTargets?: boolean | null;
+};
+declare function resolveServicePrefixedTarget<TService extends string, TTarget>(params: {
+  trimmed: string;
+  lower: string;
+  servicePrefixes: Array<ServicePrefix<TService>>;
+  isChatTarget: (remainderLower: string) => boolean;
+  parseTarget: (remainder: string) => TTarget;
+}): ({
+  kind: "handle";
+  to: string;
+  service: TService;
+} | TTarget) | null;
+declare function resolveServicePrefixedChatTarget<TService extends string, TTarget>(params: {
+  trimmed: string;
+  lower: string;
+  servicePrefixes: Array<ServicePrefix<TService>>;
+  chatIdPrefixes: string[];
+  chatGuidPrefixes: string[];
+  chatIdentifierPrefixes: string[];
+  extraChatPrefixes?: string[];
+  parseTarget: (remainder: string) => TTarget;
+}): ({
+  kind: "handle";
+  to: string;
+  service: TService;
+} | TTarget) | null;
+declare function parseChatTargetPrefixesOrThrow(params: ChatTargetPrefixesParams): ParsedChatTarget | null;
+declare function resolveServicePrefixedAllowTarget<TAllowTarget>(params: {
+  trimmed: string;
+  lower: string;
+  servicePrefixes: Array<{
+    prefix: string;
+  }>;
+  parseAllowTarget: (remainder: string) => TAllowTarget;
+}): (TAllowTarget | {
+  kind: "handle";
+  handle: string;
+}) | null;
+declare function resolveServicePrefixedOrChatAllowTarget<TAllowTarget extends ParsedChatAllowTarget>(params: {
+  trimmed: string;
+  lower: string;
+  servicePrefixes: Array<{
+    prefix: string;
+  }>;
+  parseAllowTarget: (remainder: string) => TAllowTarget;
+  chatIdPrefixes: string[];
+  chatGuidPrefixes: string[];
+  chatIdentifierPrefixes: string[];
+}): TAllowTarget | null;
+declare function createAllowedChatSenderMatcher(params: {
+  normalizeSender: (sender: string) => string;
+  parseAllowTarget: (entry: string) => ParsedChatAllowTarget;
+  allowConversationTargets?: boolean;
+}): (input: ChatSenderAllowParams) => boolean;
+declare function parseChatAllowTargetPrefixes(params: ChatTargetPrefixesParams): ParsedChatTarget | null;
+//#endregion
+//#region src/channels/plugins/tts-capabilities.d.ts
+declare function resolveChannelTtsVoiceDelivery(channel: string | undefined): ChannelTtsVoiceDeliveryCapabilities | undefined;
+//#endregion
+export { ParsedChatTarget as a, parseChatAllowTargetPrefixes as c, resolveServicePrefixedChatTarget as d, resolveServicePrefixedOrChatAllowTarget as f, ParsedChatAllowTarget as i, parseChatTargetPrefixesOrThrow as l, ChatSenderAllowParams as n, ServicePrefix as o, resolveServicePrefixedTarget as p, ChatTargetPrefixesParams as r, createAllowedChatSenderMatcher as s, resolveChannelTtsVoiceDelivery as t, resolveServicePrefixedAllowTarget as u };

package/dist/channel.setup-B0_HezV4.d.ts

@@ -0,0 +1,6 @@
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+import { o as ResolvedZalouserAccount } from "./accounts-D9GVD8d8.js";
+//#region extensions/zalouser/src/channel.setup.d.ts
+declare const zalouserSetupPlugin: ChannelPlugin<ResolvedZalouserAccount>;
+//#endregion
+export { zalouserSetupPlugin as t };

package/dist/channel.setup-C086lFEl.d.ts

@@ -0,0 +1,8 @@
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+import { t as TelegramProbe } from "./probe-NkGsuT5W.js";
+import { t as ResolvedTelegramAccount } from "./accounts-DuuWnvsL.js";
+
+//#region extensions/telegram/src/channel.setup.d.ts
+declare const telegramSetupPlugin: ChannelPlugin<ResolvedTelegramAccount, TelegramProbe>;
+//#endregion
+export { telegramSetupPlugin as t };

package/dist/channel.setup-Dxq2KPzh.d.ts

@@ -0,0 +1,7 @@
+import { n as ChannelPlugin } from "./types.public-DuFOa-9T.js";
+import { t as ResolvedDiscordAccount } from "./accounts-Dpzwwvsx.js";
+
+//#region extensions/discord/src/channel.setup.d.ts
+declare const discordSetupPlugin: ChannelPlugin<ResolvedDiscordAccount>;
+//#endregion
+export { discordSetupPlugin as t };

package/dist/chrome.executables-DjE_qOY6.d.ts

@@ -0,0 +1,13 @@
+import { n as ResolvedBrowserConfig } from "./config-3K7a2-uP.js";
+
+//#region extensions/browser/src/browser/chrome.executables.d.ts
+type BrowserExecutable = {
+  kind: "brave" | "canary" | "chromium" | "chrome" | "custom" | "edge";
+  path: string;
+};
+declare function resolveGoogleChromeExecutableForPlatform(platform: NodeJS.Platform): BrowserExecutable | null;
+declare function readBrowserVersion(executablePath: string): string | null;
+declare function parseBrowserMajorVersion(rawVersion: string | null | undefined): number | null;
+declare function resolveBrowserExecutableForPlatform(resolved: ResolvedBrowserConfig, platform: NodeJS.Platform): BrowserExecutable | null;
+//#endregion
+export { resolveGoogleChromeExecutableForPlatform as a, resolveBrowserExecutableForPlatform as i, parseBrowserMajorVersion as n, readBrowserVersion as r, BrowserExecutable as t };

package/dist/cli/gateway-lifecycle.runtime.d.ts

@@ -1,7 +1,7 @@
-import { r as DaoCoreConfig } from "../types.daocore-FLA7MxtO.js";
-import { l as getRuntimeConfig } from "../io-Dc14mjlC.js";
+import { r as DaoCoreConfig } from "../types.daocore-kp8IyikH.js";
+import { l as getRuntimeConfig } from "../io-jTMHHDSk.js";
 import { i as TaskRecord, l as TaskStatus } from "../task-registry.types-CicKx6sv.js";
-import { x as DiagnosticMemoryUsage, y as DiagnosticMemoryPressureEvent } from "../diagnostic-events-B4xTzTcy.js";
+import { x as DiagnosticMemoryUsage, y as DiagnosticMemoryPressureEvent } from "../diagnostic-events-DTdUTmJ8.js";
 import { a as waitForActiveEmbeddedRuns, c as listActiveEmbeddedRunSessionIds, l as listActiveEmbeddedRunSessionKeys, s as getActiveEmbeddedRunCount, t as abortEmbeddedPiRun } from "../runs-D-yUHGfK.js";
 import { i as waitForActiveTasks, n as markGatewayDraining, r as resetAllLanes, t as getActiveTaskCount } from "../command-queue-CvXXfohG.js";
 import { t as reloadTaskRegistryFromStore } from "../runtime-internal-Do-5YMUX.js";

package/dist/cli/run-main.d.ts

@@ -1,4 +1,4 @@
-import { r as DaoCoreConfig } from "../types.daocore-FLA7MxtO.js";
+import { r as DaoCoreConfig } from "../types.daocore-kp8IyikH.js";
 import { n as PluginManifestCommandAliasRegistry } from "../manifest-command-aliases-BBRdBljz.js";
 
 //#region src/cli/run-main-policy.d.ts

package/dist/cli-C1U-lTT9.d.ts

@@ -0,0 +1,20 @@
+import { n as AzAccount, t as AzAccessToken } from "./shared-DOgMz1o7.js";
+
+//#region extensions/microsoft-foundry/cli.d.ts
+declare function execAz(args: string[]): string;
+declare function isAzCliInstalled(): boolean;
+declare function getLoggedInAccount(): AzAccount | null;
+declare function listSubscriptions(): AzAccount[];
+type AccessTokenParams = {
+  subscriptionId?: string;
+  tenantId?: string;
+};
+declare function getAccessTokenResult(params?: AccessTokenParams): AzAccessToken;
+declare function getAccessTokenResultAsync(params?: AccessTokenParams): Promise<AzAccessToken>;
+declare function azLoginDeviceCode(): Promise<void>;
+declare function azLoginDeviceCodeWithOptions(params: {
+  tenantId?: string;
+  allowNoSubscriptions?: boolean;
+}): Promise<void>;
+//#endregion
+export { getAccessTokenResultAsync as a, listSubscriptions as c, getAccessTokenResult as i, azLoginDeviceCodeWithOptions as n, getLoggedInAccount as o, execAz as r, isAzCliInstalled as s, azLoginDeviceCode as t };

package/dist/cli-auth-seam-B3phOJyP.d.ts

@@ -0,0 +1,8 @@
+import { t as ClaudeCliCredential } from "./cli-credentials-DP01ABtj.js";
+
+//#region extensions/anthropic/cli-auth-seam.d.ts
+declare function readClaudeCliCredentialsForSetup(): ClaudeCliCredential | null;
+declare function readClaudeCliCredentialsForSetupNonInteractive(): ClaudeCliCredential | null;
+declare function readClaudeCliCredentialsForRuntime(): ClaudeCliCredential | null;
+//#endregion
+export { readClaudeCliCredentialsForSetup as n, readClaudeCliCredentialsForSetupNonInteractive as r, readClaudeCliCredentialsForRuntime as t };

package/dist/cli-backend-6UP14NL8.d.ts

@@ -0,0 +1,5 @@
+import { gr as CliBackendPlugin } from "./types-M3Y2bFvZ2.js";
+//#region extensions/google/cli-backend.d.ts
+declare function buildGoogleGeminiCliBackend(): CliBackendPlugin;
+//#endregion
+export { buildGoogleGeminiCliBackend as t };

package/dist/cli-backend-DPnuZtQT.d.ts

@@ -0,0 +1,5 @@
+import { gr as CliBackendPlugin } from "./types-M3Y2bFvZ2.js";
+//#region extensions/anthropic/cli-backend.d.ts
+declare function buildAnthropicCliBackend(): CliBackendPlugin;
+//#endregion
+export { buildAnthropicCliBackend as t };