@opengeni/api-router 3.0.1 → 3.1.2

package/dist/integrations/oauth-profiles.d.ts

@@ -13,10 +13,9 @@ import { z } from "zod";
  *
  * Profiles come from two layers:
  *
- * 1. Built-in profiles below, for the providers whose fences are security
- *    invariants (hosted Slack MCP and official Gmail are personal-only, their
- *    authorization servers are origin-pinned). These live in code as data so
- *    the fences never depend on catalog import state.
+ * 1. Built-in profiles pin known authorization servers and protocol quirks.
+ *    Ownership defaults guide setup; users may choose personal or workspace.
+ *    Authorization-server pins never depend on catalog import state.
  * 2. A validated `oauthProfile` object on a global catalog row (curated
  *    overlay -> importer -> `capability_catalog_items.metadata`). A catalog
  *    profile applies only when no built-in matches, and it can only narrow the
@@ -76,10 +75,13 @@ export type OAuthProviderProfile = {
         key: DeploymentManagedClientKey;
         message: string;
     };
-    /** Ownerships a connection may take; a singleton also sets the default. */
-    allowedOwnership: readonly ConnectionOwnership[];
-    /** Exact 422 message when an explicit disallowed ownership is requested. */
-    ownershipMessage?: string;
+    /** Suggested ownership; explicit choices remain subject to requiredOwnership. */
+    defaultOwnership?: ConnectionOwnership;
+    /** Built-in-only ownership restriction, including old reconnect/callback state. */
+    requiredOwnership?: {
+        ownership: ConnectionOwnership;
+        message: string;
+    };
     /** Bind reconnect/dedupe to the exact mcpUrl, not just the provider domain. */
     exactMcpBinding: boolean;
     /** How an existing connection is chosen for reconnect coalescing. */
@@ -106,6 +108,35 @@ export type OAuthProviderProfile = {
     extraAuthorizeParams?: Readonly<Record<string, string>>;
     /** Exact scope override; the caller can never widen past it. */
     requestedScopes?: readonly string[];
+    /** Reviewed local bridge grant normalization and token verification. Catalog profiles cannot supply code. */
+    normalizeGrantedScopes?: (scopes: readonly string[] | string) => string[];
+    reportedScopesRequired?: boolean;
+    /** Built-in durable API bridges may refuse a new grant without offline access. */
+    freshRefreshTokenRequired?: boolean;
+    /** The reviewed bridge exposes one tool contract, not a partial-scope variant. */
+    fullRequestedScopesRequired?: boolean;
+    /** Built-in web OAuth clients must use a configured secret and provider-supported authentication. */
+    confidentialClientRequired?: boolean;
+    /** Built-in API bridge discovery; catalog metadata cannot redirect this seam. */
+    providerOAuthDiscovery?: {
+        issuer: string;
+        metadataUrl: string;
+    };
+    localToolVerification?: {
+        url: string;
+        method?: "GET" | "POST";
+        /** An API bridge may require a verified account before accepting a grant. */
+        required?: boolean;
+        /** Distinguish a rejected OAuth grant from a temporary verification failure. */
+        isRejectedGrant?: (payload: Record<string, unknown>) => boolean;
+        validateIdentity: (payload: Record<string, unknown>) => Record<string, string>;
+        toolsForScopes: (scopes: readonly string[], deployment: {
+            gmailWatchTopicName?: string | undefined;
+        }) => Array<{
+            name: string;
+            description?: string;
+        }>;
+    };
 };
 export declare const DEFAULT_OAUTH_PROFILE: OAuthProviderProfile;
 /** Exact built-in profile by its stable key; throws on an unknown key. */
@@ -133,8 +164,6 @@ export declare function builtInOAuthProfileFor(input: {
 }): OAuthProviderProfile | null;
 /** Ownership an omitted request defaults to under a profile. */
 export declare function defaultOwnershipFor(profile: OAuthProviderProfile): ConnectionOwnership;
-/** Rejects an ownership outside the profile's allowed set with its exact message. */
-export declare function assertOwnershipAllowed(profile: OAuthProviderProfile, ownership: ConnectionOwnership): void;
 /** Enforces a profile's authorization-server origin pins with its exact message. */
 export declare function assertAuthorizationServerPins(as: PinnableAuthorizationServer, pins: Pick<AuthorizationServerPins, "issuerOrigins" | "authorizationEndpointOrigins" | "tokenEndpointOrigins" | "message">): void;
 /**
@@ -166,10 +195,10 @@ export declare const catalogOAuthProfileSchema: z.ZodObject<{
     pinnedIssuerOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     pinnedEndpointOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     sendResourceParameter: z.ZodOptional<z.ZodBoolean>;
-    allowedOwnership: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    defaultOwnership: z.ZodOptional<z.ZodEnum<{
         personal: "personal";
         workspace: "workspace";
-    }>>>;
+    }>>;
     requestedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     extraAuthorizeParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strict>;
@@ -190,6 +219,6 @@ export declare function catalogMcpUrlKey(value: string): string;
  *
  * A present-but-invalid profile fails closed with a 422: the row's operator
  * declared constraints, and silently degrading to the default profile would
- * drop an ownership fence or origin pin on a JSON typo.
+ * drop an origin pin on a JSON typo.
  */
 export declare function oauthProfileFromCatalog(mcpUrl: string, raw: unknown): OAuthProviderProfile;

package/dist/integrations/onepassword-vault-provider.d.ts

@@ -0,0 +1,9 @@
+import type { OnePasswordVaultProviderFactory } from "@opengeni/core";
+/**
+ * Loads the 1Password adapter (and its ~14 MB WASM SDK) only when a request
+ * first touches 1Password. The only allowed import edge, besides apps/worker,
+ * is this dynamic one (OP-5, packages/vaults-onepassword/test/import-guard.test.ts).
+ */
+export declare const loadOnePasswordVaultProvider: OnePasswordVaultProviderFactory;
+/** The offline token check and connection-scoped provider used by the install route. */
+export declare function loadOnePasswordModule(): Promise<typeof import("@opengeni/vaults-onepassword")>;

package/dist/integrations/slack-bot.d.ts

@@ -4,6 +4,7 @@ import { type Database } from "@opengeni/db";
 import { type FetchLike } from "@opengeni/network";
 import { HTTPException } from "hono/http-exception";
 export declare const SLACK_REACTION_IMAGE_MAX_BYTES: number;
+export declare const SLACK_MCP_IMAGE_MAX_BYTES: number;
 declare const SLACK_REACTION_CONTEXT_CHECKPOINT_VERSION = 1;
 type SlackPayload = Record<string, unknown> & {
     ok?: unknown;
@@ -137,7 +138,7 @@ export type SlackHomeBlock = {
 } | {
     type: "divider";
 };
-type SlackBotOperation = "channels.list" | "search.context" | "channel_history.read" | "thread_replies.read" | "users.list" | "files.list" | "file.info" | "file.content.read" | "home.publish" | "message.post" | "message.update" | "message.delete";
+type SlackBotOperation = "channels.list" | "search.context" | "channel_history.read" | "thread_replies.read" | "users.list" | "files.list" | "file.info" | "file.content.read" | "file.upload" | "home.publish" | "message.post" | "message.update" | "message.delete";
 type SlackBotContext = {
     accountId: string;
     workspaceId: string;
@@ -189,6 +190,25 @@ export declare class SlackBotProviderError extends Error {
     readonly retryAfterMs: number | null;
     constructor(code: string, retryAfterMs?: number | null);
 }
+export declare function slackHistoryRateLimited(error: unknown): error is SlackBotProviderError;
+/**
+ * The post or update ledger already binds this operation id to different
+ * request bytes. Raised from the durable claim, before any Slack write, so a
+ * caller that knows an earlier release wrote other bytes for the same operation
+ * may retry once with those bytes.
+ */
+export declare class SlackBotOperationConflictError extends Error {
+    constructor(kind: "post" | "update" | "delete");
+}
+/** Only Slack's one-time HTTPS upload endpoint may receive retained bytes. */
+export declare function slackFileUploadUrl(value: string): URL;
+/** A channel listing alone is not proof of delivery to the requested thread. */
+export declare function slackFileSharedToThread(value: unknown, input: {
+    fileId: string;
+    channelId: string;
+    threadTimestamp: string;
+    botUserId: string;
+}): boolean;
 export declare function authorizeSlackSharedImageRead(channel: {
     isArchived: boolean;
     isShared: boolean;
@@ -221,7 +241,143 @@ export declare function resolveSlackBotConnectionForTool(input: {
     connection: ConnectionMetadata;
     metadata: OpenGeniSlackBotConnectionMetadata;
     context: SlackBotContext;
+    sharingGeneration?: number;
+    authorizeOrganizationAccess?: SlackProviderAuthorization;
+}>;
+/**
+ * The one destination a scheduled run may post to as the Opengeni bot: the
+ * channel a person chose on the task, through the bot connection frozen on the
+ * run's session. The agent never supplies a channel. Every call re-reads the
+ * task, so a person clearing or changing the channel takes effect at once.
+ */
+export declare function resolveScheduledSlackBotPostTarget(input: {
+    db: Database;
+    grant: AccessGrant;
+    sessionId: string | null;
+}): Promise<Awaited<ReturnType<typeof resolveSlackBotConnectionForTool>> & {
+    scheduledTaskId: string;
+    channelId: string;
+}>;
+/**
+ * Save one message for the task's channel without sending it. The returned id
+ * is server-owned and becomes the Slack post operation id, so retrying the
+ * send can never post the same message twice.
+ */
+export declare function prepareScheduledSlackBotPost(input: {
+    db: Database;
+    grant: AccessGrant;
+    sessionId: string | null;
+    text: string;
+    threadTimestamp?: string | undefined;
+}): Promise<{
+    messageId: string;
+    identity: "workspace_bot";
+    channelId: string;
+    threadTimestamp: string | null;
+    text: string;
+    sent: boolean;
+}>;
+/** Ordinary chats choose an explicit channel; scheduled roots retain their
+ * person-chosen destination and cannot enter this path through a child. */
+export declare function prepareSlackBotPost(input: {
+    db: Database;
+    grant: AccessGrant;
+    sessionId: string | null;
+    text: string;
+    channelId?: string;
+    connectionId?: string;
+    threadTimestamp?: string;
+}): Promise<{
+    messageId: string;
+    identity: "workspace_bot";
+    channelId: string;
+    threadTimestamp: string | null;
+    text: string;
+    sent: boolean;
+} | {
+    messageId: string;
+    identity: "organization_bot";
+    channelId: string;
+    threadTimestamp: string | null;
+    text: string;
+    sent: boolean;
 }>;
+/** The saved server-owned identity, destination, text and sharing generation
+ * are immutable. Neither a reconnect nor a revoked/re-enabled share redirects it. */
+export declare function sendSlackBotPost(input: {
+    db: Database;
+    settings: Settings;
+    grant: AccessGrant;
+    sessionId: string | null;
+    messageId: string;
+    slackFetch?: typeof fetch;
+    authorizeProviderRequest?: SlackProviderAuthorization;
+}): Promise<{
+    channelId: string | null;
+    timestamp: string | null;
+    threadTimestamp: string | null;
+    alreadySent: boolean;
+    receipt: {
+        credentialRole: "opengeni_slack_bot";
+        credentialLabel: "OpenGeni Slack bot";
+        connectionId: string;
+        operation: string;
+        operationId: string;
+        clientMessageId: string;
+    };
+} | {
+    channelId: string;
+    timestamp: string;
+    threadTimestamp: string | null;
+    receipt: SlackBotReceipt;
+}>;
+/**
+ * Send a message this run prepared, exactly as saved. The destination must
+ * still be the task's channel and the bot connection unchanged; otherwise the
+ * send is refused rather than redirected.
+ */
+export declare function sendScheduledSlackBotPost(input: {
+    db: Database;
+    settings: Settings;
+    grant: AccessGrant;
+    sessionId: string | null;
+    messageId: string;
+    slackFetch?: typeof fetch;
+    authorizeProviderRequest?: SlackProviderAuthorization;
+}): Promise<{
+    channelId: string | null;
+    timestamp: string | null;
+    threadTimestamp: string | null;
+    alreadySent: boolean;
+    receipt: {
+        credentialRole: "opengeni_slack_bot";
+        credentialLabel: "OpenGeni Slack bot";
+        connectionId: string;
+        operation: string;
+        operationId: string;
+        clientMessageId: string;
+    };
+} | {
+    channelId: string;
+    timestamp: string;
+    threadTimestamp: string | null;
+    receipt: SlackBotReceipt;
+}>;
+/**
+ * Check, with the bot's token, that a person's chosen task channel is one the
+ * bot is a member of, active, and not shared with another organization.
+ */
+export declare function verifyScheduledTaskSlackChannel(deps: {
+    db: Database;
+    settings: Settings;
+    slackFetch?: typeof fetch;
+}, input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    connectionId: string;
+    channelId: string;
+}): Promise<void>;
 export declare class OpenGeniSlackBotClient {
     private readonly db;
     private readonly settings;
@@ -230,8 +386,12 @@ export declare class OpenGeniSlackBotClient {
     private readonly context;
     private readonly fetchImpl;
     private readonly authorizeProviderRequest?;
+    private readonly authorizeBotAccess?;
     private readonly resolveCredential;
-    constructor(db: Database, settings: Settings, connection: ConnectionMetadata, metadata: OpenGeniSlackBotConnectionMetadata, context: SlackBotContext, fetchImpl?: FetchLike, authorizeProviderRequest?: SlackProviderAuthorization | undefined);
+    private readonly rateLimit;
+    constructor(db: Database, settings: Settings, connection: ConnectionMetadata, metadata: OpenGeniSlackBotConnectionMetadata, context: SlackBotContext, fetchImpl?: FetchLike, authorizeProviderRequest?: SlackProviderAuthorization | undefined, authorizeBotAccess?: ((method: string) => Promise<boolean | void>) | undefined);
+    private historyPageLimit;
+    private postReconciliationPageLimit;
     listChannels(input?: {
         limit?: number;
         cursor?: string;
@@ -243,6 +403,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -266,6 +427,7 @@ export declare class OpenGeniSlackBotClient {
         isMember: boolean;
         isDirectMessage: boolean;
         isMpim: boolean;
+        userId: string | null;
         isArchived: boolean;
         isShared: boolean;
         isExternallyShared: boolean;
@@ -278,6 +440,50 @@ export declare class OpenGeniSlackBotClient {
         purpose: string;
         numMembers: number | null;
     }>;
+    /** Server-only upload preparation; the temporary URL never enters a tool result. */
+    allocateFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        filename: string;
+        sizeBytes: number;
+    }): Promise<{
+        fileId: string;
+        uploadUrl: URL;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
+    transferFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        uploadUrl: URL;
+        bytes: Uint8Array;
+    }): Promise<{
+        uploaded: boolean;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
+    completeFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        threadTimestamp: string;
+        fileId: string;
+        title: string;
+    }): Promise<{
+        fileId: string;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
+    reconcileFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        threadTimestamp: string;
+        fileId: string;
+    }): Promise<{
+        shared: boolean;
+    } & {
+        receipt: SlackBotReceipt;
+    }>;
+    private requireFileUploadScope;
     /**
      * Replace one Slack user's private App Home view. `views.publish` is a
      * naturally convergent replace operation: Slack event retries may safely
@@ -300,6 +506,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -321,6 +528,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -357,6 +565,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -408,6 +617,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -448,7 +658,6 @@ export declare class OpenGeniSlackBotClient {
         messageTimestamp: string;
         checkpoint: unknown | null;
         checkpointBinding: SlackReactionContextCheckpointBinding;
-        saveCheckpoint: (checkpoint: SlackReactionContextCheckpoint) => Promise<void>;
     }): Promise<{
         channel: {
             id: string;
@@ -457,6 +666,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -507,6 +717,7 @@ export declare class OpenGeniSlackBotClient {
             }[];
         }[];
         truncated: boolean;
+        contextUnavailable?: boolean;
     } & {
         receipt: SlackBotReceipt;
     }>;
@@ -544,8 +755,9 @@ export declare class OpenGeniSlackBotClient {
         receipt: SlackBotReceipt;
     }>;
     /**
-     * Workspace-wide public search through Slack's Real-time Search API
-     * (`assistant.search.context`) under the bot identity.
+     * Public search in a trusted Slack interaction through Real-time Search
+     * (`assistant.search.context`) under the bot identity. Unlisted deployments
+     * cannot use this API; approved deployments also need Slack's action token.
      *
      * The bot never carries private-search authority: `channel_types` is pinned
      * to `public_channel` server-side regardless of caller input, so private
@@ -555,6 +767,8 @@ export declare class OpenGeniSlackBotClient {
      */
     searchContext(input: {
         query: string;
+        /** Server-owned Slack interaction token, never an agent tool argument. */
+        actionToken?: string;
         contentTypes?: readonly ("messages" | "files" | "channels")[];
         includeBots?: boolean;
         /** UNIX seconds bounds on message timestamps. */
@@ -610,6 +824,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -649,6 +864,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -680,7 +896,51 @@ export declare class OpenGeniSlackBotClient {
         fileId: string;
         parentFileId?: string;
         offset?: number;
-    }): Promise<{
+    }): Promise<({
+        channel: {
+            id: string;
+            name: string;
+            isPrivate: boolean;
+            isMember: boolean;
+            isDirectMessage: boolean;
+            isMpim: boolean;
+            userId: string | null;
+            isArchived: boolean;
+            isShared: boolean;
+            isExternallyShared: boolean;
+            isOrgShared: boolean;
+            isPendingExternallyShared: boolean;
+            contextTeamId: string | null;
+            connectedTeamIds: string[] | null;
+            sharedTeamIds: string[] | null;
+            topic: string;
+            purpose: string;
+            numMembers: number | null;
+        };
+        file: {
+            id: string;
+            name: string;
+            title: string;
+            mimetype: string;
+            filetype: string;
+            mode: string;
+            size: number | null;
+            originatingHuddleId: string;
+            huddleTranscriptFileId: string;
+        };
+        image: Readonly<{
+            fileId: string;
+            filename: string;
+            contentType: "image/png" | "image/jpeg" | "image/webp";
+            bytes: Uint8Array;
+        }>;
+        contentType?: never;
+        offset?: never;
+        content?: never;
+        nextOffset?: never;
+        truncated?: never;
+    } | {
+        image?: never;
         channel: {
             id: string;
             name: string;
@@ -688,6 +948,7 @@ export declare class OpenGeniSlackBotClient {
             isMember: boolean;
             isDirectMessage: boolean;
             isMpim: boolean;
+            userId: string | null;
             isArchived: boolean;
             isShared: boolean;
             isExternallyShared: boolean;
@@ -716,7 +977,7 @@ export declare class OpenGeniSlackBotClient {
         content: string;
         nextOffset: number | null;
         truncated: boolean;
-    } & {
+    }) & {
         receipt: SlackBotReceipt;
     }>;
     /**
@@ -783,11 +1044,14 @@ export declare class OpenGeniSlackBotClient {
     private recordAudit;
     private auditMetadata;
 }
+/** Full decode guards the model image block against header-only or corrupt files. */
+export declare function validateSlackMcpImage(bytes: Uint8Array): Promise<void>;
 export declare function createOpenGeniSlackBotClient(deps: {
     db: Database;
     settings: Settings;
     slackFetch?: typeof fetch;
     authorizeProviderRequest?: SlackProviderAuthorization;
+    authorizeBotMutation?: () => Promise<void>;
 }, resolved: Awaited<ReturnType<typeof resolveSlackBotConnectionForTool>>): OpenGeniSlackBotClient;
 export declare function createOpenGeniSlackBotInteractionClient(deps: {
     db: Database;
@@ -801,6 +1065,12 @@ export declare function createOpenGeniSlackBotInteractionClient(deps: {
     subjectId: string;
     sessionId?: string | null;
 }): Promise<OpenGeniSlackBotClient>;
+/** A private route needs live provider proof of the exact linked requester's bot IM. */
+export declare function assertSlackPrivateTaskRecipient(channel: {
+    isDirectMessage: boolean;
+    isMpim: boolean;
+    userId: string | null;
+}, slackUserId: string): void;
 export declare function sniffSlackReactionImageMime(bytes: Uint8Array): "image/png" | "image/jpeg" | "image/webp" | null;
 export declare function resolveSlackFilesListPage(input: {
     channelId: string;
@@ -813,4 +1083,12 @@ export declare function createSlackFilesListCursor(input: {
     page: number;
 }, context: SlackFilesCursorContext): string;
 export declare function nextSlackFilesListPage(payload: SlackPayload, requested: SlackFilesListPage, returnedFileCount: number): number | null;
+/**
+ * Slack action IDs are unique within a block. Keep the logical card untouched
+ * for the durable request digest, and partition repeated actions only on the
+ * provider wire. In particular, a legacy invalid_blocks receipt can retry with
+ * its original operation ID and digest; completed/uncertain posts keep their
+ * existing replay/reconciliation path. Values and action IDs remain exact.
+ */
+export declare function slackMessageWireBlocks(blocks: SlackMessageBlock[] | undefined): SlackMessageBlock[] | undefined;
 export {};

package/dist/integrations/slack-file-upload-flow.d.ts

@@ -0,0 +1,62 @@
+/** Durability port: checkpoints must be lease-fenced before any provider write. */
+export type SlackFileUploadPhase = "pending" | "uploading" | "uploaded" | "completing" | "outcome_unknown" | "completed";
+export type SlackFileUploadState = {
+    phase: SlackFileUploadPhase;
+    slackFileId: string | null;
+};
+export type SlackFileUploadProvider = {
+    allocateFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        filename: string;
+        sizeBytes: number;
+    }): Promise<{
+        fileId: string;
+        uploadUrl: URL;
+    }>;
+    transferFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        uploadUrl: URL;
+        bytes: Uint8Array;
+    }): Promise<unknown>;
+    completeFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        threadTimestamp: string;
+        fileId: string;
+        title: string;
+    }): Promise<unknown>;
+    reconcileFileUpload(input: {
+        channelId: string;
+        privateRecipientSlackUserId?: string;
+        threadTimestamp: string;
+        fileId: string;
+    }): Promise<{
+        shared: boolean;
+    }>;
+};
+export declare class SlackFileUploadClaimLostError extends Error {
+    constructor();
+}
+export declare class SlackFileUploadOutcomeUnknownError extends Error {
+    constructor();
+}
+/** No automatic retries. An uncertain completion is reconciled, never resent. */
+export declare function runSlackFileUpload(input: {
+    state: SlackFileUploadState;
+    provider: SlackFileUploadProvider;
+    checkpoint: (update: {
+        expectedPhase: SlackFileUploadPhase;
+        phase: SlackFileUploadPhase;
+        slackFileId?: string;
+    }) => Promise<boolean>;
+    channelId: string;
+    privateRecipientSlackUserId?: string;
+    threadTimestamp: string;
+    filename: string;
+    bytes: Uint8Array;
+}): Promise<{
+    slackFileId: string;
+    replayed: boolean;
+}>;