@automate.ax/integration-contracts 0.55.0

package/dist/slack/schemas.js

@@ -0,0 +1,581 @@
+import { z } from "zod";
+export const SLACK_JSON_OBJECT_SCHEMA = z.record(z.string(), z.json());
+export const SLACK_BLOCKS_SCHEMA = SLACK_JSON_OBJECT_SCHEMA.array().max(50);
+export const SLACK_RESPONSE_METADATA_SCHEMA = z.object({
+    /** Opaque cursor for the next page, when more results are available. */
+    nextCursor: z.string().optional(),
+});
+export const SLACK_TOPIC_SCHEMA = z.object({
+    /** Slack user ID that last changed the value. */
+    creatorId: z.string().optional(),
+    /** Unix timestamp in seconds when the value was last changed. */
+    lastSetAt: z.number().int().nonnegative().optional(),
+    /** Current topic or purpose text. */
+    value: z.string(),
+});
+export const SLACK_CONVERSATION_SCHEMA = z.object({
+    /** Unix timestamp in seconds when Slack created the conversation. */
+    createdAt: z.number().int().nonnegative().optional(),
+    /** Slack user ID that created the conversation. */
+    creatorId: z.string().optional(),
+    /** Stable Slack conversation ID. */
+    id: z.string(),
+    /** Whether the conversation is archived. */
+    isArchived: z.boolean().optional(),
+    /** Whether this is the workspace's general channel. */
+    isGeneral: z.boolean().optional(),
+    /** Whether the authenticated bot belongs to the conversation. */
+    isMember: z.boolean().optional(),
+    /** Whether this is a direct-message conversation. */
+    isDirectMessage: z.boolean().optional(),
+    /** Whether this is a multi-person direct-message conversation. */
+    isGroupDirectMessage: z.boolean().optional(),
+    /** Whether this conversation is private. */
+    isPrivate: z.boolean().optional(),
+    /** Whether this conversation is shared with another workspace. */
+    isShared: z.boolean().optional(),
+    /** Human-readable conversation name, when applicable. */
+    name: z.string().optional(),
+    /** Slack-normalized conversation name. */
+    normalizedName: z.string().optional(),
+    /** Number of conversation members, when Slack includes it. */
+    memberCount: z.number().int().nonnegative().optional(),
+    /** Conversation purpose metadata. */
+    purpose: SLACK_TOPIC_SCHEMA.optional(),
+    /** Conversation topic metadata. */
+    topic: SLACK_TOPIC_SCHEMA.optional(),
+    /** Slack user ID for the other participant in a direct message. */
+    userId: z.string().optional(),
+});
+export const SLACK_MEMBER_PROFILE_SCHEMA = z.object({
+    /** User's selected display name. */
+    displayName: z.string().optional(),
+    /** Email address, only when the account also has `users:read.email`. */
+    email: z.string().optional(),
+    /** User's first name. */
+    firstName: z.string().optional(),
+    /** URL for the user's 192-pixel avatar. */
+    image192: z.string().optional(),
+    /** URL for the user's 512-pixel avatar. */
+    image512: z.string().optional(),
+    /** URL for the user's 72-pixel avatar. */
+    image72: z.string().optional(),
+    /** User's last name. */
+    lastName: z.string().optional(),
+    /** Preferred pronouns. */
+    pronouns: z.string().optional(),
+    /** User's real name from their profile. */
+    realName: z.string().optional(),
+    /** Emoji used for the user's custom status. */
+    statusEmoji: z.string().optional(),
+    /** Unix timestamp when the custom status expires. */
+    statusExpiration: z.number().int().nonnegative().optional(),
+    /** User's custom status text. */
+    statusText: z.string().optional(),
+    /** User's job title. */
+    title: z.string().optional(),
+});
+export const SLACK_MEMBER_SCHEMA = z.object({
+    /** Whether this member represents an installed Slack app. */
+    isAppUser: z.boolean().optional(),
+    /** Whether this member is a workspace administrator. */
+    isAdmin: z.boolean().optional(),
+    /** Whether this member is a bot. */
+    isBot: z.boolean().optional(),
+    /** Whether this member is the workspace owner. */
+    isOwner: z.boolean().optional(),
+    /** Whether this member is a guest. */
+    isRestricted: z.boolean().optional(),
+    /** Whether this member is a single-channel guest. */
+    isUltraRestricted: z.boolean().optional(),
+    /** Whether this member has been deactivated. */
+    deleted: z.boolean().optional(),
+    /** Stable Slack user ID. */
+    id: z.string(),
+    /** Legacy Slack username. */
+    name: z.string().optional(),
+    /** Rich workspace profile fields. */
+    profile: SLACK_MEMBER_PROFILE_SCHEMA,
+    /** IANA time zone name configured for the member. */
+    timeZone: z.string().optional(),
+    /** Human-readable time zone label. */
+    timeZoneLabel: z.string().optional(),
+    /** Time zone offset from UTC in seconds. */
+    timeZoneOffset: z.number().int().optional(),
+    /** Unix timestamp in seconds when the member was last updated. */
+    updatedAt: z.number().int().nonnegative().optional(),
+    /** Slack workspace ID containing the member. */
+    workspaceId: z.string().optional(),
+});
+export const SLACK_REACTION_SCHEMA = z.object({
+    /** Number of users that added this reaction. */
+    count: z.number().int().nonnegative(),
+    /** Emoji name without surrounding colons. */
+    name: z.string(),
+    /** Slack user IDs included in the response sample. */
+    userIds: z.string().array(),
+});
+export const SLACK_MESSAGE_SCHEMA = z.object({
+    /** Slack app ID that produced the message. */
+    appId: z.string().optional(),
+    /** Provider-native legacy attachment payloads. */
+    attachments: SLACK_JSON_OBJECT_SCHEMA.array().optional(),
+    /** Block Kit content. */
+    blocks: SLACK_BLOCKS_SCHEMA.optional(),
+    /** Slack bot ID that produced the message. */
+    botId: z.string().optional(),
+    /** Files attached to the message as provider-native Slack objects. */
+    files: SLACK_JSON_OBJECT_SCHEMA.array().optional(),
+    /** Slack user ID of the thread parent author. */
+    parentUserId: z.string().optional(),
+    /** Emoji reactions currently attached to the message. */
+    reactions: SLACK_REACTION_SCHEMA.array().optional(),
+    /** Number of replies to this message. */
+    replyCount: z.number().int().nonnegative().optional(),
+    /** Message subtype supplied by Slack. */
+    subtype: z.string().optional(),
+    /** Plain-text message content or accessibility fallback. */
+    text: z.string(),
+    /** Parent message timestamp when this message belongs to a thread. */
+    threadTimestamp: z.string().optional(),
+    /** Stable Slack message timestamp. */
+    timestamp: z.string(),
+    /** Slack message event type. */
+    type: z.string(),
+    /** Slack user ID that authored the message. */
+    userId: z.string().optional(),
+});
+export const SLACK_REACTION_ITEM_SCHEMA = z.discriminatedUnion("type", [
+    z.object({
+        /** Slack conversation containing the reacted-to message. */
+        conversationId: z.string(),
+        /** Provider conversation category such as `channel`, `group`, or `im`. */
+        conversationType: z.string().optional(),
+        /** Timestamp identifying the reacted-to message. */
+        messageTimestamp: z.string(),
+        type: z.literal("message"),
+    }),
+    z.object({
+        /** Stable Slack file ID. */
+        fileId: z.string(),
+        type: z.literal("file"),
+    }),
+    z.object({
+        /** Stable Slack file ID. */
+        fileId: z.string(),
+        /** Stable Slack file-comment ID. */
+        fileCommentId: z.string(),
+        type: z.literal("fileComment"),
+    }),
+]);
+export const SLACK_REACTION_EVENT_SCHEMA = z.object({
+    /** Slack timestamp identifying when the event occurred. */
+    eventTimestamp: z.string(),
+    /** Reacted-to Slack item. */
+    item: SLACK_REACTION_ITEM_SCHEMA,
+    /** Author of the reacted-to item, when Slack can identify one. */
+    itemUserId: z.string().optional(),
+    /** Emoji name without surrounding colons. */
+    reaction: z.string(),
+    /** Slack user who added or removed the reaction. */
+    userId: z.string(),
+    /** Slack workspace in which the event occurred. */
+    workspaceId: z.string(),
+});
+export const SLACK_FILE_SCHEMA = z.object({
+    /** Channels in which the file is shared. */
+    channelIds: z.string().array().optional(),
+    /** Unix timestamp in seconds when Slack created the file. */
+    createdAt: z.number().int().nonnegative().optional(),
+    /** Slack file type such as `png` or `javascript`. */
+    fileType: z.string().optional(),
+    /** Stable Slack file ID. */
+    id: z.string(),
+    /** MIME media type reported by Slack. */
+    mimeType: z.string().optional(),
+    /** Original filename. */
+    name: z.string().optional(),
+    /** Slack permalink for the file. */
+    permalink: z.string().optional(),
+    /** File size in bytes. */
+    size: z.number().int().nonnegative().optional(),
+    /** Human-readable title. */
+    title: z.string().optional(),
+    /** Authenticated URL for downloading the file. */
+    urlPrivate: z.string().optional(),
+    /** Slack user ID that uploaded the file. */
+    userId: z.string().optional(),
+});
+export const SLACK_WORKSPACE_IDENTITY_SCHEMA = z.object({
+    /** Slack bot ID for the authenticated installation. */
+    botId: z.string().optional(),
+    /** Enterprise Grid organization ID, when applicable. */
+    enterpriseId: z.string().optional(),
+    /** Human-readable authenticated bot name. */
+    user: z.string().optional(),
+    /** Slack user ID for the authenticated bot. */
+    userId: z.string(),
+    /** Workspace URL. */
+    url: z.string().optional(),
+    /** Human-readable workspace name. */
+    workspace: z.string(),
+    /** Stable Slack workspace ID. */
+    workspaceId: z.string(),
+});
+export const SLACK_MESSAGE_CONTENT_SCHEMA = z
+    .object({
+    /** Provider-native legacy attachment payloads. */
+    attachments: SLACK_JSON_OBJECT_SCHEMA.array().max(100).optional(),
+    /** Block Kit content. */
+    blocks: SLACK_BLOCKS_SCHEMA.optional(),
+    /** Whether Slack should parse and unfurl links. */
+    unfurlLinks: z.boolean().optional(),
+    /** Whether Slack should unfurl media. */
+    unfurlMedia: z.boolean().optional(),
+    /** Plain text or accessibility fallback for Block Kit messages. */
+    text: z.string().optional(),
+})
+    .refine(({ attachments, blocks, text }) => attachments !== undefined || blocks !== undefined || text !== undefined, "At least one of text, blocks, or attachments must be provided.");
+export const SLACK_CURSOR_INPUT_SCHEMA = z.object({
+    /** Opaque cursor returned by the previous page. */
+    cursor: z.string().min(1).optional(),
+    /** Maximum number of results requested from Slack. */
+    limit: z.number().int().min(1).max(200).optional(),
+});
+export const SLACK_PROVIDER_RESPONSE_METADATA_SCHEMA = z
+    .object({
+    next_cursor: z.string().optional(),
+})
+    .optional();
+export const SLACK_PROVIDER_TOPIC_SCHEMA = z.object({
+    creator: z.string().optional(),
+    last_set: z.number().int().nonnegative().optional(),
+    value: z.string(),
+});
+export const SLACK_PROVIDER_CONVERSATION_SCHEMA = z.looseObject({
+    created: z.number().int().nonnegative().optional(),
+    creator: z.string().optional(),
+    id: z.string(),
+    is_archived: z.boolean().optional(),
+    is_general: z.boolean().optional(),
+    is_im: z.boolean().optional(),
+    is_member: z.boolean().optional(),
+    is_mpim: z.boolean().optional(),
+    is_private: z.boolean().optional(),
+    is_shared: z.boolean().optional(),
+    name: z.string().optional(),
+    name_normalized: z.string().optional(),
+    num_members: z.number().int().nonnegative().optional(),
+    purpose: SLACK_PROVIDER_TOPIC_SCHEMA.optional(),
+    topic: SLACK_PROVIDER_TOPIC_SCHEMA.optional(),
+    user: z.string().optional(),
+});
+export const SLACK_PROVIDER_MEMBER_PROFILE_SCHEMA = z.looseObject({
+    display_name: z.string().optional(),
+    email: z.string().optional(),
+    first_name: z.string().optional(),
+    image_192: z.string().optional(),
+    image_512: z.string().optional(),
+    image_72: z.string().optional(),
+    last_name: z.string().optional(),
+    pronouns: z.string().optional(),
+    real_name: z.string().optional(),
+    status_emoji: z.string().optional(),
+    status_expiration: z.number().int().nonnegative().optional(),
+    status_text: z.string().optional(),
+    title: z.string().optional(),
+});
+export const SLACK_PROVIDER_MEMBER_SCHEMA = z.looseObject({
+    deleted: z.boolean().optional(),
+    id: z.string(),
+    is_admin: z.boolean().optional(),
+    is_app_user: z.boolean().optional(),
+    is_bot: z.boolean().optional(),
+    is_owner: z.boolean().optional(),
+    is_restricted: z.boolean().optional(),
+    is_ultra_restricted: z.boolean().optional(),
+    name: z.string().optional(),
+    profile: SLACK_PROVIDER_MEMBER_PROFILE_SCHEMA.prefault({}),
+    team_id: z.string().optional(),
+    tz: z.string().optional(),
+    tz_label: z.string().optional(),
+    tz_offset: z.number().int().optional(),
+    updated: z.number().int().nonnegative().optional(),
+});
+export const SLACK_PROVIDER_REACTION_SCHEMA = z.object({
+    count: z.number().int().nonnegative(),
+    name: z.string(),
+    users: z.string().array().optional(),
+});
+export const SLACK_PROVIDER_MESSAGE_SCHEMA = z
+    .looseObject({
+    app_id: z.string().optional(),
+    attachments: SLACK_JSON_OBJECT_SCHEMA.array().optional(),
+    blocks: SLACK_BLOCKS_SCHEMA.optional(),
+    bot_id: z.string().optional(),
+    files: SLACK_JSON_OBJECT_SCHEMA.array().optional(),
+    parent_user_id: z.string().optional(),
+    reactions: SLACK_PROVIDER_REACTION_SCHEMA.array().optional(),
+    reply_count: z.number().int().nonnegative().optional(),
+    subtype: z.string().optional(),
+    text: z.string().prefault(""),
+    thread_ts: z.string().optional(),
+    ts: z.string(),
+    type: z.string().prefault("message"),
+    user: z.string().optional(),
+})
+    .catchall(z.json());
+const SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA = SLACK_PROVIDER_MESSAGE_SCHEMA.extend({
+    channel: z.string(),
+    channel_type: z.string().optional(),
+    event_ts: z.string(),
+});
+export const SLACK_MESSAGE_EVENT_SCHEMA = SLACK_MESSAGE_SCHEMA.extend({
+    /** Slack conversation containing the message. */
+    conversationId: z.string(),
+    /** Provider conversation category such as `channel`, `group`, or `im`. */
+    conversationType: z.string().optional(),
+    /** Original provider event. */
+    event: SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA,
+    /** Slack timestamp identifying when the event occurred. */
+    eventTimestamp: z.string(),
+    /** Slack workspace in which the event occurred. */
+    workspaceId: z.string(),
+});
+export const SLACK_APP_MENTION_EVENT_SCHEMA = SLACK_MESSAGE_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA.extend({
+        type: z.literal("app_mention"),
+    }),
+    type: z.literal("app_mention"),
+});
+export const SLACK_MESSAGE_POSTED_EVENT_SCHEMA = SLACK_MESSAGE_EVENT_SCHEMA.extend({
+    event: SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA.extend({
+        type: z.literal("message"),
+    }),
+    type: z.literal("message"),
+});
+const SLACK_PROVIDER_REACTION_ITEM_SCHEMA = z.discriminatedUnion("type", [
+    z.looseObject({
+        channel: z.string(),
+        channel_type: z.string().optional(),
+        ts: z.string(),
+        type: z.literal("message"),
+    }),
+    z.looseObject({
+        file: z.string(),
+        type: z.literal("file"),
+    }),
+    z.looseObject({
+        file: z.string(),
+        file_comment: z.string(),
+        type: z.literal("file_comment"),
+    }),
+]);
+const SLACK_PROVIDER_REACTION_EVENT_SCHEMA = z.looseObject({
+    event_ts: z.string(),
+    item: SLACK_PROVIDER_REACTION_ITEM_SCHEMA,
+    item_user: z.string().optional(),
+    reaction: z.string(),
+    user: z.string(),
+});
+export const SLACK_PROVIDER_FILE_SCHEMA = z.looseObject({
+    channels: z.string().array().optional(),
+    created: z.number().int().nonnegative().optional(),
+    filetype: z.string().optional(),
+    id: z.string(),
+    mimetype: z.string().optional(),
+    name: z.string().optional(),
+    permalink: z.string().optional(),
+    size: z.number().int().nonnegative().optional(),
+    title: z.string().optional(),
+    url_private: z.string().optional(),
+    user: z.string().optional(),
+});
+/**
+ * Normalizes Slack cursor metadata.
+ *
+ * @param metadata - Provider-native cursor metadata.
+ */
+export function toSlackResponseMetadata(metadata) {
+    return {
+        ...(metadata?.next_cursor && { nextCursor: metadata.next_cursor }),
+    };
+}
+/**
+ * Normalizes a Slack topic or purpose object.
+ *
+ * @param topic - Provider-native topic fields.
+ */
+export function toSlackTopic(topic) {
+    return {
+        creatorId: topic.creator,
+        lastSetAt: topic.last_set,
+        value: topic.value,
+    };
+}
+/**
+ * Normalizes a Slack conversation.
+ *
+ * @param conversation - Provider-native conversation fields.
+ */
+export function toSlackConversation(conversation) {
+    return {
+        createdAt: conversation.created,
+        creatorId: conversation.creator,
+        id: conversation.id,
+        isArchived: conversation.is_archived,
+        isDirectMessage: conversation.is_im,
+        isGeneral: conversation.is_general,
+        isGroupDirectMessage: conversation.is_mpim,
+        isMember: conversation.is_member,
+        isPrivate: conversation.is_private,
+        isShared: conversation.is_shared,
+        memberCount: conversation.num_members,
+        name: conversation.name,
+        normalizedName: conversation.name_normalized,
+        purpose: conversation.purpose
+            ? toSlackTopic(conversation.purpose)
+            : undefined,
+        topic: conversation.topic ? toSlackTopic(conversation.topic) : undefined,
+        userId: conversation.user,
+    };
+}
+/**
+ * Normalizes a Slack workspace member.
+ *
+ * @param member - Provider-native member fields.
+ */
+export function toSlackMember(member) {
+    return {
+        deleted: member.deleted,
+        id: member.id,
+        isAdmin: member.is_admin,
+        isAppUser: member.is_app_user,
+        isBot: member.is_bot,
+        isOwner: member.is_owner,
+        isRestricted: member.is_restricted,
+        isUltraRestricted: member.is_ultra_restricted,
+        name: member.name,
+        profile: {
+            displayName: member.profile.display_name,
+            email: member.profile.email,
+            firstName: member.profile.first_name,
+            image192: member.profile.image_192,
+            image512: member.profile.image_512,
+            image72: member.profile.image_72,
+            lastName: member.profile.last_name,
+            pronouns: member.profile.pronouns,
+            realName: member.profile.real_name,
+            statusEmoji: member.profile.status_emoji,
+            statusExpiration: member.profile.status_expiration,
+            statusText: member.profile.status_text,
+            title: member.profile.title,
+        },
+        timeZone: member.tz,
+        timeZoneLabel: member.tz_label,
+        timeZoneOffset: member.tz_offset,
+        updatedAt: member.updated,
+        workspaceId: member.team_id,
+    };
+}
+/**
+ * Normalizes a Slack message.
+ *
+ * @param message - Provider-native message fields.
+ */
+export function toSlackMessage(message) {
+    return {
+        appId: message.app_id,
+        attachments: message.attachments,
+        blocks: message.blocks,
+        botId: message.bot_id,
+        files: message.files,
+        parentUserId: message.parent_user_id,
+        reactions: message.reactions?.map((reaction) => ({
+            count: reaction.count,
+            name: reaction.name,
+            userIds: reaction.users ?? [],
+        })),
+        replyCount: message.reply_count,
+        subtype: message.subtype,
+        text: message.text,
+        threadTimestamp: message.thread_ts,
+        timestamp: message.ts,
+        type: message.type,
+        userId: message.user,
+    };
+}
+/**
+ * Normalizes a message-shaped Slack Events API payload.
+ *
+ * @param event - Provider-native inner event.
+ * @param workspaceId - Slack workspace from the outer event envelope.
+ */
+export function normalizeSlackMessageEvent(event, workspaceId) {
+    const parsedEvent = SLACK_PROVIDER_MESSAGE_EVENT_SCHEMA.parse(event);
+    return SLACK_MESSAGE_EVENT_SCHEMA.parse({
+        ...toSlackMessage(parsedEvent),
+        conversationId: parsedEvent.channel,
+        conversationType: parsedEvent.channel_type,
+        event: parsedEvent,
+        eventTimestamp: parsedEvent.event_ts,
+        workspaceId,
+    });
+}
+/**
+ * Normalizes a reaction-shaped Slack Events API payload.
+ *
+ * @param event - Provider-native inner event.
+ * @param workspaceId - Slack workspace from the outer event envelope.
+ */
+export function normalizeSlackReactionEvent(event, workspaceId) {
+    const parsedEvent = SLACK_PROVIDER_REACTION_EVENT_SCHEMA.parse(event);
+    // Keep the discriminated provider-to-public item mapping readable as a unit.
+    const item = (() => {
+        switch (parsedEvent.item.type) {
+            case "message":
+                return {
+                    conversationId: parsedEvent.item.channel,
+                    conversationType: parsedEvent.item.channel_type,
+                    messageTimestamp: parsedEvent.item.ts,
+                    type: "message",
+                };
+            case "file":
+                return { fileId: parsedEvent.item.file, type: "file" };
+            case "file_comment":
+                return {
+                    fileCommentId: parsedEvent.item.file_comment,
+                    fileId: parsedEvent.item.file,
+                    type: "fileComment",
+                };
+        }
+    })();
+    return SLACK_REACTION_EVENT_SCHEMA.parse({
+        eventTimestamp: parsedEvent.event_ts,
+        item,
+        itemUserId: parsedEvent.item_user,
+        reaction: parsedEvent.reaction,
+        userId: parsedEvent.user,
+        workspaceId,
+    });
+}
+/**
+ * Normalizes a Slack file.
+ *
+ * @param file - Provider-native file fields.
+ */
+export function toSlackFile(file) {
+    return {
+        channelIds: file.channels,
+        createdAt: file.created,
+        fileType: file.filetype,
+        id: file.id,
+        mimeType: file.mimetype,
+        name: file.name,
+        permalink: file.permalink,
+        size: file.size,
+        title: file.title,
+        urlPrivate: file.url_private,
+        userId: file.user,
+    };
+}

package/dist/teams/graph.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+/** Options accepted by the authenticated Teams Graph request helper. */
+export interface TeamsGraphRequestOptions {
+    /** JSON-serializable request body. */
+    body?: unknown;
+    /** Additional HTTP headers. */
+    headers?: RequestInit["headers"];
+    /** HTTP method. */
+    method?: string;
+}
+/**
+ * Creates a small authenticated Microsoft Graph client for Teams APIs.
+ *
+ * The raw `fetch` method is an escape hatch for Graph operations not yet
+ * represented by a built-in action.
+ *
+ * @param secret - Refreshed Microsoft OAuth integration secret.
+ */
+export declare function getTeamsGraphApi(secret: Record<string, unknown>): {
+    /** Performs an authenticated request and returns the raw Response. */
+    fetch: (path: string, init?: RequestInit) => Promise<Response>;
+    /** Performs an authenticated request and returns its untrusted JSON value. */
+    request: (path: string, options?: TeamsGraphRequestOptions) => Promise<unknown>;
+};
+/**
+ * Reads Graph collection pages until the requested limit is reached.
+ *
+ * @param request - Authenticated Graph JSON request function.
+ * @param path - Initial relative Graph path.
+ * @param itemSchema - Schema for one collection item.
+ * @param limit - Maximum total items.
+ */
+export declare function listTeamsGraphCollection<T>(request: (path: string) => Promise<unknown>, path: string, itemSchema: z.ZodType<T>, limit: number): Promise<T[]>;