roboport 0.0.1

package/triggers/sources/github.d.ts

@@ -0,0 +1,148 @@
+import type { Trigger } from '../core';
+interface GithubUser {
+    login: string;
+    id: number;
+    type: 'User' | 'Bot' | 'Organization' | string;
+}
+interface GithubRepository {
+    id: number;
+    name: string;
+    full_name: string;
+    owner: GithubUser;
+    default_branch: string;
+    private: boolean;
+    html_url: string;
+}
+interface GithubLabel {
+    id: number;
+    name: string;
+    color?: string;
+}
+interface GithubPullRef {
+    ref: string;
+    sha: string;
+    repo: GithubRepository | null;
+}
+interface GithubPullRequest {
+    number: number;
+    state: 'open' | 'closed';
+    title: string;
+    body: string | null;
+    draft: boolean;
+    merged: boolean;
+    head: GithubPullRef;
+    base: GithubPullRef;
+    user: GithubUser;
+    labels: GithubLabel[];
+    html_url: string;
+}
+interface GithubIssue {
+    number: number;
+    state: 'open' | 'closed';
+    title: string;
+    body: string | null;
+    user: GithubUser;
+    labels: GithubLabel[];
+    pull_request?: {
+        url: string;
+    };
+    html_url: string;
+}
+interface GithubComment {
+    id: number;
+    body: string;
+    user: GithubUser;
+    html_url: string;
+}
+interface GithubReviewComment extends GithubComment {
+    path: string;
+    line: number | null;
+    start_line: number | null;
+    commit_id: string;
+    diff_hunk: string;
+    pull_request_review_id: number | null;
+    in_reply_to_id?: number;
+}
+interface GithubPushCommit {
+    id: string;
+    message: string;
+    url: string;
+    author: {
+        name: string;
+        email: string;
+        username?: string;
+    };
+}
+interface PullRequestEvent {
+    action: string;
+    number: number;
+    pull_request: GithubPullRequest;
+    repository: GithubRepository;
+    sender: GithubUser;
+}
+interface IssuesEvent {
+    action: string;
+    issue: GithubIssue;
+    repository: GithubRepository;
+    sender: GithubUser;
+}
+interface IssueCommentEvent {
+    action: string;
+    issue: GithubIssue;
+    comment: GithubComment;
+    repository: GithubRepository;
+    sender: GithubUser;
+}
+interface PullRequestReviewCommentEvent {
+    action: string;
+    comment: GithubReviewComment;
+    pull_request: GithubPullRequest;
+    repository: GithubRepository;
+    sender: GithubUser;
+}
+interface PushEvent {
+    ref: string;
+    before: string;
+    after: string;
+    created: boolean;
+    deleted: boolean;
+    forced: boolean;
+    commits: GithubPushCommit[];
+    head_commit: GithubPushCommit | null;
+    repository: GithubRepository;
+    sender: GithubUser;
+    pusher: {
+        name: string;
+        email: string;
+    };
+}
+interface GithubReceiverOptions {
+    secret: string;
+    deliveryCacheSize?: number;
+}
+declare class GithubReceiver {
+    private prBus;
+    private issueCommentBus;
+    private reviewCommentBus;
+    private issuesBus;
+    private pushBus;
+    private readonly secret;
+    private readonly deliveries;
+    constructor(options: GithubReceiverOptions);
+    pullRequest(opts?: {
+        actions?: string[];
+    }): Trigger<PullRequestEvent>;
+    issueComment(opts?: {
+        actions?: string[];
+    }): Trigger<IssueCommentEvent>;
+    pullRequestReviewComment(opts?: {
+        actions?: string[];
+    }): Trigger<PullRequestReviewCommentEvent>;
+    issues(opts?: {
+        actions?: string[];
+    }): Trigger<IssuesEvent>;
+    push(): Trigger<PushEvent>;
+    handle: (req: Request) => Promise<Response>;
+}
+declare function github(options: GithubReceiverOptions): GithubReceiver;
+export { github, GithubReceiver, type GithubComment, type GithubIssue, type GithubLabel, type GithubPullRef, type GithubPullRequest, type GithubPushCommit, type GithubReceiverOptions, type GithubRepository, type GithubReviewComment, type GithubUser, type IssueCommentEvent, type IssuesEvent, type PullRequestEvent, type PullRequestReviewCommentEvent, type PushEvent, };

package/triggers/sources/grafana.d.ts

@@ -0,0 +1,37 @@
+import type { Trigger } from '../core';
+type Json = Record<string, unknown>;
+type AlertStatus = 'firing' | 'resolved';
+interface GrafanaAlert {
+    status: AlertStatus;
+    labels: Record<string, string>;
+    annotations: Record<string, string>;
+    startsAt: string;
+    endsAt: string;
+    generatorURL?: string;
+    fingerprint?: string;
+    values?: Json;
+}
+interface GrafanaAlertEvent extends GrafanaAlert {
+    groupKey?: string;
+    externalURL?: string;
+}
+interface GrafanaWebhookPayload {
+    receiver?: string;
+    status?: AlertStatus;
+    alerts?: GrafanaAlert[];
+    groupLabels?: Record<string, string>;
+    commonLabels?: Record<string, string>;
+    commonAnnotations?: Record<string, string>;
+    externalURL?: string;
+    version?: string;
+    groupKey?: string;
+}
+declare class GrafanaReceiver {
+    private alertBus;
+    alert(opts?: {
+        status?: AlertStatus;
+    }): Trigger<GrafanaAlertEvent>;
+    handle: (req: Request) => Promise<Response>;
+}
+declare function grafana(): GrafanaReceiver;
+export { grafana, GrafanaReceiver, type AlertStatus, type GrafanaAlert, type GrafanaAlertEvent, type GrafanaWebhookPayload, };

package/triggers/sources/linear.d.ts

@@ -0,0 +1,39 @@
+import type { Trigger } from '../core';
+type Json = Record<string, unknown>;
+type LinearAction = 'create' | 'update' | 'remove';
+interface LinearWebhook {
+    action: LinearAction;
+    type: string;
+    data: Json;
+    url?: string;
+    createdAt?: string;
+    organizationId?: string;
+    webhookId?: string;
+    webhookTimestamp?: number;
+}
+interface LinearIssueEvent extends LinearWebhook {
+    type: 'Issue';
+}
+interface LinearCommentEvent extends LinearWebhook {
+    type: 'Comment';
+}
+interface LinearProjectEvent extends LinearWebhook {
+    type: 'Project';
+}
+declare class LinearReceiver {
+    private issueBus;
+    private commentBus;
+    private projectBus;
+    issue(opts?: {
+        actions?: LinearAction[];
+    }): Trigger<LinearIssueEvent>;
+    comment(opts?: {
+        actions?: LinearAction[];
+    }): Trigger<LinearCommentEvent>;
+    project(opts?: {
+        actions?: LinearAction[];
+    }): Trigger<LinearProjectEvent>;
+    handle: (req: Request) => Promise<Response>;
+}
+declare function linear(): LinearReceiver;
+export { linear, LinearReceiver, type LinearAction, type LinearCommentEvent, type LinearIssueEvent, type LinearProjectEvent, type LinearWebhook, };

package/triggers/sources/telegram.d.ts

@@ -0,0 +1,85 @@
+import type { Trigger } from '../core';
+interface TelegramUser {
+    id: number;
+    is_bot: boolean;
+    first_name: string;
+    last_name?: string;
+    username?: string;
+    language_code?: string;
+}
+interface TelegramChat {
+    id: number;
+    type: 'private' | 'group' | 'supergroup' | 'channel';
+    title?: string;
+    username?: string;
+    first_name?: string;
+    last_name?: string;
+}
+interface TelegramMessage {
+    message_id: number;
+    from?: TelegramUser;
+    chat: TelegramChat;
+    date: number;
+    text?: string;
+    caption?: string;
+    reply_to_message?: TelegramMessage;
+}
+interface TelegramUpdate {
+    update_id: number;
+    message?: TelegramMessage;
+    edited_message?: TelegramMessage;
+}
+type TelegramChatAction = 'typing' | 'upload_photo' | 'record_video' | 'upload_video' | 'record_voice' | 'upload_voice' | 'upload_document' | 'choose_sticker' | 'find_location';
+interface SendMessageOptions {
+    parseMode?: 'MarkdownV2' | 'HTML';
+    replyToMessageId?: number;
+    disableNotification?: boolean;
+    messageThreadId?: number;
+    linkPreview?: boolean;
+}
+interface SendMessageDraftOptions {
+    parseMode?: 'MarkdownV2' | 'HTML';
+    messageThreadId?: number;
+}
+interface TelegramReceiverOptions {
+    secretToken: string;
+    updateCacheSize?: number;
+}
+declare class TelegramReceiver {
+    private messageBus;
+    private editedMessageBus;
+    private readonly secretToken;
+    private readonly updates;
+    constructor(options: TelegramReceiverOptions);
+    message(opts?: {
+        commands?: string[];
+        botUsername?: string;
+    }): Trigger<TelegramMessage>;
+    editedMessage(): Trigger<TelegramMessage>;
+    handle: (req: Request) => Promise<Response>;
+}
+declare function splitMessage(text: string, max?: number): string[];
+declare class TelegramClient {
+    private readonly token;
+    private readonly baseUrl;
+    constructor(token: string, opts?: {
+        baseUrl?: string;
+    });
+    private call;
+    getMe(): Promise<TelegramUser>;
+    sendChatAction(chatId: number | string, action?: TelegramChatAction): Promise<boolean>;
+    sendMessage(chatId: number | string, text: string, opts?: SendMessageOptions): Promise<TelegramMessage[]>;
+    editMessageText(chatId: number | string, messageId: number, text: string, opts?: {
+        parseMode?: 'MarkdownV2' | 'HTML';
+    }): Promise<TelegramMessage | boolean>;
+    sendMessageDraft(chatId: number, draftId: number, text: string, opts?: SendMessageDraftOptions): Promise<boolean>;
+    setWebhook(url: string, opts?: {
+        secretToken?: string;
+        allowedUpdates?: string[];
+    }): Promise<boolean>;
+    deleteWebhook(opts?: {
+        dropPendingUpdates?: boolean;
+    }): Promise<boolean>;
+}
+declare function telegram(options: TelegramReceiverOptions): TelegramReceiver;
+export { telegram, TelegramClient, TelegramReceiver, splitMessage, type SendMessageDraftOptions, type SendMessageOptions, type TelegramChat, type TelegramChatAction, type TelegramMessage, type TelegramReceiverOptions, type TelegramUpdate, type TelegramUser, };