imessage-sdk 0.1.0-beta.0

package/dist/provider-CCW_6OWg.d.ts

@@ -0,0 +1,265 @@
+/** Runtime feature declaration for one configured provider connection. */
+interface IMessageCapabilities {
+    readonly messages: {
+        readonly text: boolean;
+        readonly attachments: boolean;
+        readonly replies: boolean;
+        readonly get: boolean;
+        readonly edit: boolean;
+        readonly delete: boolean;
+    };
+    readonly conversations: {
+        readonly direct: boolean;
+        readonly groups: boolean;
+        readonly get: boolean;
+        readonly markRead: boolean;
+    };
+    readonly interactions: {
+        readonly reactions: boolean;
+        readonly typingStart: boolean;
+        readonly typingStop: boolean;
+        readonly readReceipts: boolean;
+    };
+    readonly events: {
+        readonly webhooks: boolean;
+        readonly stream: boolean;
+    };
+}
+
+/** Provider names stay literal through generics but are open to custom adapters. */
+type IMessageProviderName = string;
+type IMessageAddressKind = "phone" | "email";
+interface IMessageAddress {
+    readonly kind: IMessageAddressKind;
+    readonly value: string;
+}
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type IMessageAttachmentKind = "image" | "video" | "file";
+type IMessageAttachmentSource = {
+    readonly type: "url";
+    /** A URL that the selected provider can fetch. */
+    readonly url: string;
+} | {
+    readonly type: "blob";
+    readonly data: Blob;
+} | {
+    readonly type: "bytes";
+    readonly data: Uint8Array;
+};
+interface IMessageAttachmentInput {
+    readonly kind: IMessageAttachmentKind;
+    readonly source: IMessageAttachmentSource;
+    readonly filename?: string;
+    readonly contentType?: string;
+}
+interface IMessageAttachment {
+    readonly kind: IMessageAttachmentKind;
+    readonly id?: string;
+    readonly url?: string;
+    readonly filename?: string;
+    readonly contentType?: string;
+    readonly size?: number;
+    readonly raw: unknown;
+}
+interface MessageReplyReference {
+    /** Provider-native message identifier. */
+    readonly messageId: string;
+    readonly partIndex?: number;
+}
+/** Identifies a provider message within its native conversation. */
+interface MessageLocator {
+    readonly conversationId: string;
+    readonly messageId: string;
+}
+type SendDestination = {
+    readonly conversationId: string;
+    readonly to?: never;
+} | {
+    readonly conversationId?: never;
+    readonly to: IMessageAddress | NonEmptyReadonlyArray<IMessageAddress>;
+};
+type SendContent = {
+    readonly text: string;
+    readonly attachments?: readonly IMessageAttachmentInput[];
+} | {
+    readonly text?: string;
+    readonly attachments: NonEmptyReadonlyArray<IMessageAttachmentInput>;
+};
+type SendMessageInput = SendDestination & SendContent & {
+    readonly replyTo?: MessageReplyReference;
+    readonly idempotencyKey?: string;
+    readonly metadata?: Readonly<Record<string, string>>;
+};
+interface EditMessageInput {
+    readonly text: string;
+}
+type IMessageDirection = "inbound" | "outbound";
+type IMessageService = "imessage" | "sms" | "rcs" | "unknown";
+type IMessageStatus = "pending" | "accepted" | "sent" | "delivered" | "read" | "failed";
+/**
+ * A provider-normalized message before the client adds connection identity.
+ * Provider adapters return this shape.
+ */
+interface ProviderMessage {
+    readonly providerMessageId: string;
+    /** Opaque provider-native ID, scoped to one provider connection. */
+    readonly conversationId?: string;
+    readonly direction: IMessageDirection;
+    readonly sender: IMessageAddress;
+    readonly recipients: readonly IMessageAddress[];
+    readonly text: string;
+    readonly attachments: readonly IMessageAttachment[];
+    readonly replyTo?: MessageReplyReference;
+    readonly service: IMessageService;
+    readonly status: IMessageStatus;
+    readonly providerStatus?: string;
+    readonly createdAt: Date;
+    readonly sentAt?: Date;
+    readonly deliveredAt?: Date;
+    readonly readAt?: Date;
+    readonly raw: unknown;
+}
+type ProviderSentMessage = ProviderMessage & {
+    readonly direction: "outbound";
+};
+/** A message returned by a client bound to one provider connection. */
+type Message<TProvider extends IMessageProviderName = IMessageProviderName, TConnectionId extends string = string> = Omit<ProviderMessage, "conversationId"> & {
+    /** Equal to providerMessageId in v0.1. */
+    readonly id: string;
+    /** Provider-native when available; otherwise a non-routable imsg-sdk-v1 fallback. */
+    readonly conversationId: string;
+    readonly provider: TProvider;
+    readonly connectionId: TConnectionId;
+};
+type SentMessage<TProvider extends IMessageProviderName = IMessageProviderName, TConnectionId extends string = string> = Message<TProvider, TConnectionId> & {
+    readonly direction: "outbound";
+};
+interface OpenConversationInput {
+    readonly participants: NonEmptyReadonlyArray<IMessageAddress>;
+}
+interface ProviderConversation {
+    /** Opaque provider-native ID, scoped to one provider connection. */
+    readonly providerConversationId: string;
+    readonly participants: readonly IMessageAddress[];
+    readonly createdAt?: Date;
+    readonly raw: unknown;
+}
+type Conversation<TProvider extends IMessageProviderName = IMessageProviderName, TConnectionId extends string = string> = ProviderConversation & {
+    /** Equal to providerConversationId in v0.1; scope with provider and connectionId. */
+    readonly id: string;
+    readonly provider: TProvider;
+    readonly connectionId: TConnectionId;
+};
+type IMessageReaction = "love" | "like" | "dislike" | "laugh" | "emphasize" | "question";
+interface AddReactionInput extends MessageLocator {
+    readonly reaction: IMessageReaction;
+    readonly partIndex?: number;
+}
+type RemoveReactionInput = AddReactionInput;
+interface SubscribeOptions {
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
+}
+
+interface ProviderEventBase<TType extends string> {
+    readonly id: string;
+    readonly providerEventId?: string;
+    readonly type: TType;
+    readonly timestamp: Date;
+    readonly raw: unknown;
+}
+type ProviderMessageEventType = "message.received" | "message.sent" | "message.delivered" | "message.read" | "message.failed" | "message.edited";
+interface ProviderMessageEvent<TType extends ProviderMessageEventType = ProviderMessageEventType> extends ProviderEventBase<TType> {
+    readonly message: ProviderMessage;
+}
+interface ProviderMessageDeletedEvent extends ProviderEventBase<"message.deleted"> {
+    readonly conversationId: string;
+    readonly messageId: string;
+}
+type ProviderReactionEventType = "reaction.added" | "reaction.removed";
+interface ProviderReactionEvent<TType extends ProviderReactionEventType = ProviderReactionEventType> extends ProviderEventBase<TType> {
+    readonly conversationId: string;
+    readonly messageId: string;
+    readonly actor: IMessageAddress;
+    readonly reaction: IMessageReaction;
+    readonly partIndex?: number;
+}
+type ProviderTypingEventType = "typing.started" | "typing.stopped";
+interface ProviderTypingEvent<TType extends ProviderTypingEventType = ProviderTypingEventType> extends ProviderEventBase<TType> {
+    readonly conversationId: string;
+    /** Some group transports do not identify which participant is typing. */
+    readonly actor?: IMessageAddress;
+}
+type ProviderEvent = ProviderMessageEvent | ProviderMessageDeletedEvent | ProviderReactionEvent | ProviderTypingEvent;
+interface IMessageEventBase<TProvider extends IMessageProviderName, TConnectionId extends string, TType extends string> extends ProviderEventBase<TType> {
+    readonly provider: TProvider;
+    readonly connectionId: TConnectionId;
+}
+interface IMessageMessageEvent<TProvider extends IMessageProviderName, TConnectionId extends string, TType extends ProviderMessageEventType = ProviderMessageEventType> extends IMessageEventBase<TProvider, TConnectionId, TType> {
+    readonly message: Message<TProvider, TConnectionId>;
+}
+interface IMessageDeletedEvent<TProvider extends IMessageProviderName, TConnectionId extends string> extends IMessageEventBase<TProvider, TConnectionId, "message.deleted"> {
+    readonly conversationId: string;
+    readonly messageId: string;
+}
+interface IMessageReactionEvent<TProvider extends IMessageProviderName, TConnectionId extends string, TType extends ProviderReactionEventType = ProviderReactionEventType> extends IMessageEventBase<TProvider, TConnectionId, TType> {
+    readonly conversationId: string;
+    readonly messageId: string;
+    readonly actor: IMessageAddress;
+    readonly reaction: IMessageReaction;
+    readonly partIndex?: number;
+}
+interface IMessageTypingEvent<TProvider extends IMessageProviderName, TConnectionId extends string, TType extends ProviderTypingEventType = ProviderTypingEventType> extends IMessageEventBase<TProvider, TConnectionId, TType> {
+    readonly conversationId: string;
+    readonly actor?: IMessageAddress;
+}
+type IMessageEvent<TProvider extends IMessageProviderName = IMessageProviderName, TConnectionId extends string = string> = IMessageMessageEvent<TProvider, TConnectionId> | IMessageDeletedEvent<TProvider, TConnectionId> | IMessageReactionEvent<TProvider, TConnectionId> | IMessageTypingEvent<TProvider, TConnectionId>;
+
+interface ProviderMessages {
+    send(input: SendMessageInput): Promise<ProviderSentMessage>;
+    get?(message: MessageLocator): Promise<ProviderMessage | null>;
+    edit?(message: MessageLocator, input: EditMessageInput): Promise<ProviderMessage>;
+    delete?(message: MessageLocator): Promise<void>;
+}
+interface ProviderConversations {
+    open(input: OpenConversationInput): Promise<ProviderConversation>;
+    get?(conversationId: string): Promise<ProviderConversation | null>;
+    markRead?(conversationId: string): Promise<void>;
+}
+interface ProviderReactions {
+    add(input: AddReactionInput): Promise<void>;
+    remove(input: RemoveReactionInput): Promise<void>;
+}
+interface ProviderTyping {
+    start(conversationId: string): Promise<void>;
+    stop?(conversationId: string): Promise<void>;
+}
+interface ProviderWebhooks {
+    verify(request: Request): Promise<boolean>;
+    parse(request: Request): Promise<readonly ProviderEvent[]>;
+}
+interface ProviderEvents {
+    subscribe(options?: SubscribeOptions): AsyncIterable<ProviderEvent>;
+}
+/**
+ * Contract implemented by a provider adapter.
+ *
+ * The complete adapter is exposed at `client.providers.<name>`, so
+ * provider-specific APIs should be defined directly on the concrete provider.
+ */
+interface IMessageProvider<TName extends IMessageProviderName = IMessageProviderName, TCapabilities extends IMessageCapabilities = IMessageCapabilities> {
+    readonly name: TName;
+    readonly capabilities: TCapabilities;
+    readonly messages: ProviderMessages;
+    readonly conversations: ProviderConversations;
+    readonly reactions?: ProviderReactions;
+    readonly typing?: ProviderTyping;
+    readonly webhooks?: ProviderWebhooks;
+    readonly events?: ProviderEvents;
+    close?(): Promise<void>;
+}
+type AnyIMessageProvider = IMessageProvider<IMessageProviderName, IMessageCapabilities>;
+/** Preserves the concrete name, capabilities, and methods of an adapter. */
+declare function defineProvider<const TProvider extends AnyIMessageProvider>(provider: TProvider): TProvider;
+
+export { type AnyIMessageProvider as A, type ProviderEvents as B, type Conversation as C, type ProviderMessage as D, type EditMessageInput as E, type ProviderMessageDeletedEvent as F, type ProviderMessageEvent as G, type ProviderMessageEventType as H, type IMessageEvent as I, type ProviderMessages as J, type ProviderReactionEvent as K, type ProviderReactionEventType as L, type MessageLocator as M, type NonEmptyReadonlyArray as N, type OpenConversationInput as O, type ProviderConversation as P, type ProviderReactions as Q, type RemoveReactionInput as R, type SendMessageInput as S, type ProviderSentMessage as T, type ProviderTyping as U, type ProviderTypingEvent as V, type ProviderTypingEventType as W, type ProviderWebhooks as X, defineProvider as Y, type SentMessage as a, type Message as b, type AddReactionInput as c, type SubscribeOptions as d, type IMessageAddress as e, type IMessageAddressKind as f, type IMessageAttachment as g, type IMessageAttachmentInput as h, type IMessageAttachmentKind as i, type IMessageAttachmentSource as j, type IMessageCapabilities as k, type IMessageDeletedEvent as l, type IMessageDirection as m, type IMessageEventBase as n, type IMessageMessageEvent as o, type IMessageProvider as p, type IMessageProviderName as q, type IMessageReaction as r, type IMessageReactionEvent as s, type IMessageService as t, type IMessageStatus as u, type IMessageTypingEvent as v, type MessageReplyReference as w, type ProviderConversations as x, type ProviderEvent as y, type ProviderEventBase as z };

package/dist/providers/blooio.d.ts

@@ -0,0 +1,76 @@
+import { x as ProviderConversations, P as ProviderConversation, u as IMessageStatus, t as IMessageService, J as ProviderMessages, M as MessageLocator, D as ProviderMessage, e as IMessageAddress, p as IMessageProvider, Q as ProviderReactions, U as ProviderTyping, X as ProviderWebhooks } from '../provider-CCW_6OWg.js';
+
+declare const BLOOIO_CAPABILITIES: {
+    readonly messages: {
+        readonly text: true;
+        readonly attachments: true;
+        readonly replies: true;
+        readonly get: true;
+        readonly edit: false;
+        readonly delete: false;
+    };
+    readonly conversations: {
+        readonly direct: true;
+        readonly groups: false;
+        readonly get: true;
+        readonly markRead: true;
+    };
+    readonly interactions: {
+        readonly reactions: true;
+        readonly typingStart: true;
+        readonly typingStop: true;
+        readonly readReceipts: true;
+    };
+    readonly events: {
+        readonly webhooks: true;
+        readonly stream: false;
+    };
+};
+interface BlooioOptions {
+    readonly apiKey?: string;
+    readonly sender?: IMessageAddress;
+    readonly webhookSecret?: string;
+    readonly baseUrl?: string;
+}
+interface BlooioMessageStatus {
+    readonly messageId: string;
+    readonly conversationId: string;
+    readonly status: IMessageStatus;
+    readonly providerStatus?: string;
+    readonly service: IMessageService;
+    readonly sentAt?: Date;
+    readonly deliveredAt?: Date;
+    readonly error?: string;
+    readonly raw: unknown;
+}
+type BlooioPlanKind = "shared" | "dedicated" | "inbound" | "trial" | "2fa";
+interface BlooioNumber {
+    readonly phoneNumber: string;
+    readonly active: boolean;
+    readonly lastActive?: Date;
+    readonly planKind?: BlooioPlanKind;
+    readonly raw: unknown;
+}
+interface BlooioNumbers {
+    list(): Promise<readonly BlooioNumber[]>;
+}
+interface BlooioMessages extends ProviderMessages {
+    get(message: MessageLocator): Promise<ProviderMessage | null>;
+    getStatus(message: MessageLocator): Promise<BlooioMessageStatus | null>;
+}
+interface BlooioConversations extends ProviderConversations {
+    get(conversationId: string): Promise<ProviderConversation | null>;
+    markRead(conversationId: string): Promise<void>;
+}
+interface BlooioProvider extends IMessageProvider<"blooio", typeof BLOOIO_CAPABILITIES> {
+    readonly messages: BlooioMessages;
+    readonly conversations: BlooioConversations;
+    readonly reactions: ProviderReactions;
+    readonly typing: Required<ProviderTyping>;
+    readonly webhooks: ProviderWebhooks;
+    readonly numbers: BlooioNumbers;
+}
+/** Creates a Blooio v2 provider. No initialization call is required. */
+declare function blooio(options?: BlooioOptions): BlooioProvider;
+
+export { BLOOIO_CAPABILITIES, type BlooioConversations, type BlooioMessageStatus, type BlooioMessages, type BlooioNumber, type BlooioNumbers, type BlooioOptions, type BlooioPlanKind, type BlooioProvider, blooio };