@rnsk/toolkits 0.0.8 → 0.0.10

package/dist/toolkits/slack/tools/admin-invites.js

@@ -0,0 +1,75 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackListApprovedInvites = tool({
+    description: 'List approved workspace invite requests with approver details. Enterprise Grid with admin.invites:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID filter (omit for all org workspaces)'),
+        limit: z.number().min(1).max(1000).optional().describe('Invites per page (max 1000, default 100)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.inviteRequests.approved.list', {
+                ...rest,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list approved invites');
+        }
+    },
+});
+export const slackListDeniedInvites = tool({
+    description: 'List denied workspace invite requests with who denied them and when. Enterprise Grid with admin.invites:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID (required for Enterprise Grid orgs)'),
+        limit: z.number().min(1).max(1000).optional().describe('Invites per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.inviteRequests.denied.list', {
+                ...rest,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list denied invites');
+        }
+    },
+});
+export const slackListPendingInvites = tool({
+    description: 'List pending workspace invite requests (invited but not yet joined). Requires admin.invites:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID filter (omit for all accessible workspaces)'),
+        limit: z.number().min(1).max(1000).optional().describe('Invites per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.inviteRequests.list', {
+                ...rest,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list pending invites');
+        }
+    },
+});
+//# sourceMappingURL=admin-invites.js.map

package/dist/toolkits/slack/tools/admin-users.d.ts

@@ -0,0 +1,52 @@
+export declare const slackAddEnterpriseUserToWorkspace: import("ai").Tool<{
+    teamId: string;
+    userId: string;
+    slackToken?: string | undefined;
+    channelIds?: string | undefined;
+    isRestricted?: boolean | undefined;
+    isUltraRestricted?: boolean | undefined;
+}, any>;
+export declare const slackInviteUserToWorkspace: import("ai").Tool<{
+    teamId: string;
+    email: string;
+    channelIds: string;
+    slackToken?: string | undefined;
+    isRestricted?: boolean | undefined;
+    isUltraRestricted?: boolean | undefined;
+    realName?: string | undefined;
+    customMessage?: string | undefined;
+    resend?: boolean | undefined;
+    guestExpirationTs?: string | undefined;
+    emailPasswordPolicyEnabled?: boolean | undefined;
+}, any>;
+export declare const slackRemoveUserFromWorkspace: import("ai").Tool<{
+    teamId: string;
+    userId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetAdminUser: import("ai").Tool<{
+    teamId: string;
+    userId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetWorkspaceOwner: import("ai").Tool<{
+    teamId: string;
+    userId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackResetUserSessions: import("ai").Tool<{
+    userId: string;
+    slackToken?: string | undefined;
+    webOnly?: boolean | undefined;
+    mobileOnly?: boolean | undefined;
+}, any>;
+export declare const slackListWorkspaceUsers: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    isActive?: boolean | undefined;
+    onlyGuests?: boolean | undefined;
+    includeDeactivatedUserWorkspaces?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=admin-users.d.ts.map

package/dist/toolkits/slack/tools/admin-users.js

@@ -0,0 +1,182 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackAddEnterpriseUserToWorkspace = tool({
+    description: 'Add an existing Enterprise Grid user to a workspace, with optional channels and guest restrictions. Enterprise Grid only.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID to add the user to'),
+        userId: z.string().describe('Enterprise user ID to add'),
+        channelIds: z.string().optional().describe('Comma-separated channel IDs for the user to join'),
+        isRestricted: z.boolean().optional().describe('Add as a multi-channel guest'),
+        isUltraRestricted: z.boolean().optional().describe('Add as a single-channel guest'),
+    }),
+    execute: async ({ slackToken, teamId, userId, channelIds, isRestricted, isUltraRestricted }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.assign', {
+                team_id: teamId,
+                user_id: userId,
+                channel_ids: channelIds,
+                is_restricted: isRestricted,
+                is_ultra_restricted: isUltraRestricted,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to add user to workspace');
+        }
+    },
+});
+export const slackInviteUserToWorkspace = tool({
+    description: 'Invite a person to a workspace by email with channels, a welcome message, and guest options (Enterprise Grid admin). Use resend=true to re-process a pending invite.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID to invite to'),
+        email: z.string().describe('Email address of the invitee'),
+        channelIds: z.string().describe('Comma-separated channel IDs (IDs only, names fail)'),
+        realName: z.string().optional().describe('Full name of the invitee'),
+        customMessage: z.string().optional().describe('Welcome note in the invite email'),
+        resend: z.boolean().optional().describe('Resend a pending invite'),
+        isRestricted: z.boolean().optional().describe('Invite as a multi-channel guest'),
+        isUltraRestricted: z.boolean().optional().describe('Invite as a single-channel guest'),
+        guestExpirationTs: z.string().optional().describe("Guest expiry as 'XXXXXXXXXX.XXXXXX'"),
+        emailPasswordPolicyEnabled: z.boolean().optional().describe('Allow email+password sign-in (Enterprise Grid)'),
+    }),
+    execute: async ({ slackToken, teamId, email, channelIds, realName, customMessage, resend, isRestricted, isUltraRestricted, guestExpirationTs, emailPasswordPolicyEnabled }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.invite', {
+                team_id: teamId,
+                email,
+                channel_ids: channelIds,
+                real_name: realName,
+                custom_message: customMessage,
+                resend,
+                is_restricted: isRestricted,
+                is_ultra_restricted: isUltraRestricted,
+                guest_expiration_ts: guestExpirationTs,
+                email_password_policy_enabled: emailPasswordPolicyEnabled,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to invite user to workspace');
+        }
+    },
+});
+export const slackRemoveUserFromWorkspace = tool({
+    description: 'Remove a user from a workspace, revoking access. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID to remove the user from'),
+        userId: z.string().describe('User ID to remove'),
+    }),
+    execute: async ({ slackToken, teamId, userId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.remove', { team_id: teamId, user_id: userId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to remove user from workspace');
+        }
+    },
+});
+export const slackSetAdminUser = tool({
+    description: 'Promote an existing workspace member (guest, user, or owner) to admin. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        userId: z.string().describe('Member ID to promote'),
+    }),
+    execute: async ({ slackToken, teamId, userId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.setAdmin', { team_id: teamId, user_id: userId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set admin user');
+        }
+    },
+});
+export const slackSetWorkspaceOwner = tool({
+    description: 'Promote a member, guest, or admin to workspace owner. Enterprise Grid only. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().describe('Workspace ID'),
+        userId: z.string().describe('Member ID to promote'),
+    }),
+    execute: async ({ slackToken, teamId, userId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.setOwner', { team_id: teamId, user_id: userId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set workspace owner');
+        }
+    },
+});
+export const slackResetUserSessions = tool({
+    description: 'Wipe all sessions on all devices for a user, forcing re-authentication. Use for security concerns. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        userId: z.string().describe('User ID to wipe sessions for'),
+        webOnly: z.boolean().optional().describe('Expire web sessions only'),
+        mobileOnly: z.boolean().optional().describe('Expire mobile sessions only'),
+    }),
+    execute: async ({ slackToken, userId, webOnly, mobileOnly }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.session.reset', {
+                user_id: userId,
+                web_only: webOnly,
+                mobile_only: mobileOnly,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to reset user sessions');
+        }
+    },
+});
+export const slackListWorkspaceUsers = tool({
+    description: 'List admin users of a workspace (admin.users.list), paginated. Omit teamId with org-level tokens for org-wide results.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID to list users for'),
+        limit: z.number().min(1).optional().describe('Users per page (default 100)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        isActive: z.boolean().optional().describe('True for active users, false for deactivated'),
+        onlyGuests: z.boolean().optional().describe('Return guest accounts with expirations only'),
+        includeDeactivatedUserWorkspaces: z.boolean().optional().describe('Include deactivated workspaces (org-level tokens)'),
+    }),
+    execute: async ({ slackToken, teamId, isActive, onlyGuests, includeDeactivatedUserWorkspaces, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.users.list', {
+                ...rest,
+                team_id: teamId,
+                is_active: isActive,
+                only_guests: onlyGuests,
+                include_deactivated_user_workspaces: includeDeactivatedUserWorkspaces,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list workspace users');
+        }
+    },
+});
+//# sourceMappingURL=admin-users.js.map

package/dist/toolkits/slack/tools/audit.d.ts

@@ -0,0 +1,20 @@
+export declare const slackReadAuditLogs: import("ai").Tool<{
+    action?: string | undefined;
+    limit?: number | undefined;
+    actor?: string | undefined;
+    latest?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    oldest?: number | undefined;
+    entity?: string | undefined;
+}, any>;
+export declare const slackGetAuditActions: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetAuditSchemas: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetScimConfig: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=audit.d.ts.map

package/dist/toolkits/slack/tools/audit.js

@@ -0,0 +1,81 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackGet, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackReadAuditLogs = tool({
+    description: 'Read Enterprise Grid audit logs (logins, admin changes, app installs, channel changes) with filters and pagination. Requires an owner/admin user token with auditlogs:read.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        action: z.string().optional().describe("Comma-separated actions (max 30), e.g. 'user_login,channel_created'"),
+        actor: z.string().optional().describe('Filter to actions by this user ID'),
+        entity: z.string().optional().describe('Filter to actions affecting this entity ID'),
+        oldest: z.number().optional().describe('Oldest entry Unix timestamp (inclusive)'),
+        latest: z.number().optional().describe('Latest entry Unix timestamp (inclusive)'),
+        limit: z.number().max(9999).optional().describe('Max entries to return (max 9999)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackGet(slackToken, 'https://api.slack.com/audit/v1/logs', rest);
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to read audit logs');
+        }
+    },
+});
+export const slackGetAuditActions = tool({
+    description: 'List action types available in the Audit Logs API by category. Use to build action filters for slackReadAuditLogs.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackGet(slackToken, 'https://api.slack.com/audit/v1/actions');
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get audit actions');
+        }
+    },
+});
+export const slackGetAuditSchemas = tool({
+    description: 'List object schemas returned by the Audit Logs API (workspaces, users, channels, etc.).',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackGet(slackToken, 'https://api.slack.com/audit/v1/schemas');
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get audit schemas');
+        }
+    },
+});
+export const slackGetScimConfig = tool({
+    description: "Get the SCIM service provider configuration (auth schemes, filtering, sorting, bulk support). No parameters. Needs a token with admin scope; SCIM-provisioned tokens may be required.",
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackGet(slackToken, 'https://api.slack.com/scim/v1/ServiceProviderConfig');
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get SCIM config');
+        }
+    },
+});
+//# sourceMappingURL=audit.js.map

package/dist/toolkits/slack/tools/calls.d.ts

@@ -0,0 +1,38 @@
+export declare const slackStartCall: import("ai").Tool<{
+    externalUniqueId: string;
+    joinUrl: string;
+    title?: string | undefined;
+    users?: string | undefined;
+    slackToken?: string | undefined;
+    createdBy?: string | undefined;
+    dateStart?: number | undefined;
+    externalDisplayId?: string | undefined;
+    desktopAppJoinUrl?: string | undefined;
+}, any>;
+export declare const slackGetCallInfo: import("ai").Tool<{
+    id: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackUpdateCallInfo: import("ai").Tool<{
+    id: string;
+    title?: string | undefined;
+    slackToken?: string | undefined;
+    joinUrl?: string | undefined;
+    desktopAppJoinUrl?: string | undefined;
+}, any>;
+export declare const slackEndCall: import("ai").Tool<{
+    id: string;
+    duration?: number | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackAddCallParticipants: import("ai").Tool<{
+    id: string;
+    users: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackRemoveCallParticipants: import("ai").Tool<{
+    id: string;
+    users: string;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=calls.d.ts.map

package/dist/toolkits/slack/tools/calls.js

@@ -0,0 +1,141 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackStartCall = tool({
+    description: 'Register a third-party call in Slack (calls.add). Requires a provider join_url and unique external_unique_id. Returns the Slack call ID for later updates.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        externalUniqueId: z.string().describe('Provider-unique call ID'),
+        joinUrl: z.string().describe('Web join URL (third-party, not a Slack URL)'),
+        title: z.string().optional().describe('Call title shown in Slack'),
+        users: z.string().optional().describe('JSON array of participants, e.g. [{"slack_id":"U123"}]'),
+        createdBy: z.string().optional().describe('Creator user ID (required without a user token)'),
+        dateStart: z.number().optional().describe('Start time as UTC Unix timestamp'),
+        externalDisplayId: z.string().optional().describe('Human-friendly meeting label, e.g. CONF-7890'),
+        desktopAppJoinUrl: z.string().optional().describe('Deep link to launch the calling app'),
+    }),
+    execute: async ({ slackToken, externalUniqueId, joinUrl, title, users, createdBy, dateStart, externalDisplayId, desktopAppJoinUrl }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.add', {
+                external_unique_id: externalUniqueId,
+                join_url: joinUrl,
+                title,
+                users,
+                created_by: createdBy,
+                date_start: dateStart,
+                external_display_id: externalDisplayId,
+                desktop_app_join_url: desktopAppJoinUrl,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to start call');
+        }
+    },
+});
+export const slackGetCallInfo = tool({
+    description: 'Get a point-in-time snapshot of a call by its Slack call ID (from slackStartCall).',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID, e.g. R1234567890'),
+    }),
+    execute: async ({ slackToken, id }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.info', { id });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get call info');
+        }
+    },
+});
+export const slackUpdateCallInfo = tool({
+    description: 'Update the title, join URL, or desktop app URL of an existing call by ID.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID to update'),
+        title: z.string().optional().describe('New call title'),
+        joinUrl: z.string().optional().describe('New web join URL'),
+        desktopAppJoinUrl: z.string().optional().describe('New desktop app deep link'),
+    }),
+    execute: async ({ slackToken, id, title, joinUrl, desktopAppJoinUrl }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.update', {
+                id,
+                title,
+                join_url: joinUrl,
+                desktop_app_join_url: desktopAppJoinUrl,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to update call');
+        }
+    },
+});
+export const slackEndCall = tool({
+    description: 'End an ongoing call by ID, optionally recording its duration in seconds.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID to end'),
+        duration: z.number().optional().describe('Call duration in seconds'),
+    }),
+    execute: async ({ slackToken, id, duration }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.end', { id, duration });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to end call');
+        }
+    },
+});
+export const slackAddCallParticipants = tool({
+    description: 'Add participants to an ongoing call. Users is a JSON array string of {"slack_id":"U..."} objects.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID from slackStartCall'),
+        users: z.string().describe('JSON array, e.g. [{"slack_id":"U1H77"},{"slack_id":"U2ABC123"}]'),
+    }),
+    execute: async ({ slackToken, id, users }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.participants.add', { id, users });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to add call participants');
+        }
+    },
+});
+export const slackRemoveCallParticipants = tool({
+    description: 'Remove participants from an ongoing call. Users is a JSON array string with slack_id and/or external_id per user.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        id: z.string().describe('Call ID to update'),
+        users: z.string().describe('JSON array, e.g. [{"slack_id":"U1H77"}]'),
+    }),
+    execute: async ({ slackToken, id, users }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'calls.participants.remove', { id, users });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to remove call participants');
+        }
+    },
+});
+//# sourceMappingURL=calls.js.map

package/dist/toolkits/slack/tools/canvas.d.ts

@@ -0,0 +1,24 @@
+export declare const slackCreateCanvas: import("ai").Tool<{
+    title?: string | undefined;
+    channelId?: string | undefined;
+    slackToken?: string | undefined;
+    documentContent?: Record<string, any> | undefined;
+}, any>;
+export declare const slackEditCanvas: import("ai").Tool<{
+    operation: "delete" | "replace" | "insert_after" | "insert_before" | "insert_at_start" | "insert_at_end" | "rename";
+    canvasId: string;
+    slackToken?: string | undefined;
+    documentContent?: Record<string, any> | undefined;
+    sectionId?: string | undefined;
+    titleContent?: Record<string, any> | undefined;
+}, any>;
+export declare const slackDeleteCanvas: import("ai").Tool<{
+    canvasId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackLookupCanvasSections: import("ai").Tool<{
+    criteria: Record<string, any>;
+    canvasId: string;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=canvas.d.ts.map