@inline-chat/realtime-sdk 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { InlineSdkClient } from "./sdk/inline-sdk-client.js";
-export type { InlineSdkClientOptions, InlineSdkState, InlineSdkStateStore, InlineInboundEvent, RpcInputForMethod, RpcResultForMethod, } from "./sdk/types.js";
+export type { InlineSdkClientOptions, InlineSdkSendMessageMedia, InlineSdkSendMessageParams, InlineSdkState, InlineSdkStateStore, InlineSdkUploadFileParams, InlineSdkUploadFileResult, InlineSdkUploadFileType, InlineInboundEvent, RpcInputForMethod, RpcResultForMethod, } from "./sdk/types.js";
 export type { InlineSdkLogger } from "./sdk/logger.js";
 export { JsonFileStateStore } from "./state/json-file-state-store.js";
 export { serializeStateV1, deserializeStateV1 } from "./state/serde.js";

package/dist/realtime/protocol-client.d.ts

@@ -9,6 +9,7 @@ export type ProtocolClientOptions = {
     transport: Transport;
     getConnectionInit: () => ConnectionInit | null;
     logger?: InlineSdkLogger;
+    defaultRpcTimeoutMs?: number | null;
 };
 export declare class ProtocolClient {
     readonly events: AsyncChannel<ClientEvent>;
@@ -17,7 +18,8 @@ export declare class ProtocolClient {
     state: ClientState;
     private readonly log;
     private readonly getConnectionInit;
-    private rpcContinuations;
+    private readonly defaultRpcTimeoutMs;
+    private pendingRpcRequests;
     private seq;
     private lastTimestamp;
     private sequence;
@@ -35,7 +37,7 @@ export declare class ProtocolClient {
     }): Promise<void>;
     sendRpc(method: Method, input?: RpcCall["input"]): Promise<bigint>;
     callRpc(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     private startListeners;
     private handleTransportMessage;
@@ -53,10 +55,14 @@ export declare class ProtocolClient {
     private generateId;
     private currentTimestamp;
     private completeRpcResult;
+    private ensureOpenForRpc;
     private completeRpcError;
-    private failRpcContinuation;
-    private getAndRemoveRpcContinuation;
-    private cancelAllRpcContinuations;
+    private failPendingRpcRequest;
+    private getAndRemovePendingRpcRequest;
+    private cancelAllPendingRpcRequests;
+    private resolveRpcTimeoutMs;
+    private resendPendingRpcRequests;
+    private trySendPendingRpcRequest;
 }
 export declare class ProtocolClientError extends Error {
     constructor(code: "not-authorized" | "not-connected" | "rpc-error" | "stopped" | "timeout", details?: {

package/dist/realtime/protocol-client.js

@@ -2,6 +2,7 @@ import { ClientMessage, ServerProtocolMessage } from "@inline-chat/protocol/core
 import { AsyncChannel } from "../utils/async-channel.js";
 import { PingPongService } from "./ping-pong.js";
 const emptyRpcInput = { oneofKind: undefined };
+const defaultRpcTimeoutMs = 30_000;
 export class ProtocolClient {
     events = new AsyncChannel();
     transport;
@@ -9,7 +10,8 @@ export class ProtocolClient {
     state = "connecting";
     log;
     getConnectionInit;
-    rpcContinuations = new Map();
+    defaultRpcTimeoutMs;
+    pendingRpcRequests = new Map();
     seq = 0;
     lastTimestamp = 0;
     sequence = 0;
@@ -22,6 +24,7 @@ export class ProtocolClient {
         this.transport = options.transport;
         this.log = options.logger ?? {};
         this.getConnectionInit = options.getConnectionInit;
+        this.defaultRpcTimeoutMs = normalizeRpcTimeoutMs(options.defaultRpcTimeoutMs, defaultRpcTimeoutMs);
         this.pingPong = new PingPongService({ logger: this.log });
         this.pingPong.configure(this);
         this.startListeners();
@@ -48,6 +51,7 @@ export class ProtocolClient {
         await this.transport.reconnect({ skipDelay: options?.skipDelay });
     }
     async sendRpc(method, input = emptyRpcInput) {
+        this.ensureOpenForRpc();
         const message = this.wrapMessage({
             oneofKind: "rpcCall",
             rpcCall: { method, input },
@@ -61,17 +65,20 @@ export class ProtocolClient {
             rpcCall: { method, input },
         });
         return await new Promise((resolve, reject) => {
-            const continuation = { resolve, reject };
-            this.rpcContinuations.set(message.id, continuation);
-            void this.transport.send(message).catch((error) => {
-                this.failRpcContinuation(message.id, error instanceof Error ? error : new Error("send-failed"));
-            });
-            const timeoutMs = options?.timeoutMs ?? 15_000;
-            if (timeoutMs > 0) {
-                continuation.timeout = setTimeout(() => {
-                    this.failRpcContinuation(message.id, new ProtocolClientError("timeout"));
-                }, timeoutMs);
+            const pending = {
+                message,
+                resolve,
+                reject,
+                timeoutMs: this.resolveRpcTimeoutMs(options?.timeoutMs),
+                sending: false,
+            };
+            this.pendingRpcRequests.set(message.id, pending);
+            if (pending.timeoutMs !== null) {
+                pending.timeout = setTimeout(() => {
+                    this.failPendingRpcRequest(message.id, new ProtocolClientError("timeout"));
+                }, pending.timeoutMs);
             }
+            this.trySendPendingRpcRequest(message.id);
         });
     }
     async startListeners() {
@@ -168,6 +175,7 @@ export class ProtocolClient {
         }
         this.connectionAttemptNo = 0;
         this.pingPong.start();
+        this.resendPendingRpcRequests();
     }
     async connecting() {
         this.state = "connecting";
@@ -176,7 +184,7 @@ export class ProtocolClient {
     async reset() {
         this.pingPong.stop();
         this.stopAuthenticationTimeout();
-        this.cancelAllRpcContinuations(new ProtocolClientError("stopped"));
+        this.cancelAllPendingRpcRequests(new ProtocolClientError("stopped"));
         this.state = "connecting";
     }
     startAuthenticationTimeout() {
@@ -195,8 +203,8 @@ export class ProtocolClient {
     }
     handleClientFailure() {
         this.pingPong.stop();
-        this.cancelAllRpcContinuations(new ProtocolClientError("not-connected"));
         this.stopAuthenticationTimeout();
+        this.state = "connecting";
         if (this.reconnectionTimer) {
             clearTimeout(this.reconnectionTimer);
         }
@@ -239,36 +247,80 @@ export class ProtocolClient {
         return Math.floor(Date.now() / 1000) - this.epochSeconds;
     }
     completeRpcResult(msgId, rpcResult) {
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.resolve(rpcResult);
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.resolve(rpcResult);
+    }
+    ensureOpenForRpc() {
+        if (this.state !== "open") {
+            throw new ProtocolClientError("not-connected");
+        }
     }
     completeRpcError(msgId, rpcError) {
         const error = new ProtocolClientError("rpc-error", { code: rpcError.code, message: rpcError.message });
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.reject(error);
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.reject(error);
     }
-    failRpcContinuation(msgId, error) {
-        const continuation = this.getAndRemoveRpcContinuation(msgId);
-        continuation?.reject(error);
+    failPendingRpcRequest(msgId, error) {
+        const pending = this.getAndRemovePendingRpcRequest(msgId);
+        pending?.reject(error);
     }
-    getAndRemoveRpcContinuation(msgId) {
-        const continuation = this.rpcContinuations.get(msgId);
-        if (!continuation)
+    getAndRemovePendingRpcRequest(msgId) {
+        const pending = this.pendingRpcRequests.get(msgId);
+        if (!pending)
             return null;
-        if (continuation.timeout)
-            clearTimeout(continuation.timeout);
-        this.rpcContinuations.delete(msgId);
-        return continuation;
-    }
-    cancelAllRpcContinuations(error) {
-        for (const continuation of this.rpcContinuations.values()) {
-            continuation.reject(error);
-            if (continuation.timeout)
-                clearTimeout(continuation.timeout);
+        if (pending.timeout)
+            clearTimeout(pending.timeout);
+        this.pendingRpcRequests.delete(msgId);
+        return pending;
+    }
+    cancelAllPendingRpcRequests(error) {
+        for (const pending of this.pendingRpcRequests.values()) {
+            pending.reject(error);
+            if (pending.timeout)
+                clearTimeout(pending.timeout);
+        }
+        this.pendingRpcRequests.clear();
+    }
+    resolveRpcTimeoutMs(timeoutMs) {
+        return normalizeRpcTimeoutMs(timeoutMs, this.defaultRpcTimeoutMs);
+    }
+    resendPendingRpcRequests() {
+        for (const msgId of this.pendingRpcRequests.keys()) {
+            this.trySendPendingRpcRequest(msgId);
         }
-        this.rpcContinuations.clear();
+    }
+    trySendPendingRpcRequest(msgId) {
+        const pending = this.pendingRpcRequests.get(msgId);
+        if (!pending)
+            return;
+        if (this.state !== "open")
+            return;
+        if (pending.sending)
+            return;
+        pending.sending = true;
+        void this.transport
+            .send(pending.message)
+            .catch((error) => {
+            this.log.warn?.("Failed to send RPC request; waiting for reconnect", error);
+            this.handleClientFailure();
+        })
+            .finally(() => {
+            pending.sending = false;
+        });
     }
 }
+const normalizeRpcTimeoutMs = (timeoutMs, fallback) => {
+    const resolved = timeoutMs === undefined ? fallback : timeoutMs;
+    if (resolved == null)
+        return null;
+    if (resolved === Number.POSITIVE_INFINITY)
+        return null;
+    if (!Number.isFinite(resolved))
+        return null;
+    if (resolved <= 0)
+        return null;
+    return Math.floor(resolved);
+};
 export class ProtocolClientError extends Error {
     constructor(code, details) {
         super(details?.message ?? code);

package/dist/sdk/inline-sdk-client.d.ts

@@ -1,16 +1,11 @@
-import { MessageEntities, Method, type Peer, type RpcCall, type RpcResult } from "@inline-chat/protocol/core";
+import { Method, type Peer, type RpcCall, type RpcResult } from "@inline-chat/protocol/core";
 import { type InlineIdLike } from "../ids.js";
-import type { InlineSdkClientOptions, InlineInboundEvent, InlineSdkState, MappedMethod, RpcInputForMethod, RpcResultForMethod } from "./types.js";
-type SendMessageTarget = {
-    chatId: InlineIdLike;
-    userId?: never;
-} | {
-    userId: InlineIdLike;
-    chatId?: never;
-};
+import type { InlineSdkClientOptions, InlineInboundEvent, InlineSdkSendMessageParams, InlineSdkState, InlineSdkUploadFileParams, InlineSdkUploadFileResult, MappedMethod, RpcInputForMethod, RpcResultForMethod } from "./types.js";
 export declare class InlineSdkClient {
     private readonly options;
     private readonly log;
+    private readonly httpBaseUrl;
+    private readonly fetchImpl;
     private readonly transport;
     private readonly protocol;
     private readonly eventStream;
@@ -38,27 +33,22 @@ export declare class InlineSdkClient {
         peer?: Peer;
         title: string;
     }>;
-    sendMessage(params: SendMessageTarget & {
-        text: string;
-        replyToMsgId?: InlineIdLike;
-        parseMarkdown?: boolean;
-        sendMode?: "silent";
-        entities?: MessageEntities;
-    }): Promise<{
+    sendMessage(params: InlineSdkSendMessageParams): Promise<{
         messageId: bigint | null;
     }>;
+    uploadFile(params: InlineSdkUploadFileParams): Promise<InlineSdkUploadFileResult>;
     sendTyping(params: {
         chatId: InlineIdLike;
         typing: boolean;
     }): Promise<void>;
     invokeRaw(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     invokeUncheckedRaw(method: Method, input?: RpcCall["input"], options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResult["result"]>;
     invoke<M extends MappedMethod>(method: M, input: RpcInputForMethod<M>, options?: {
-        timeoutMs?: number;
+        timeoutMs?: number | null;
     }): Promise<RpcResultForMethod<M>>;
     private assertMethodInputMatch;
     private assertMethodResultMatch;
@@ -76,4 +66,3 @@ export declare class InlineSdkClient {
     private scheduleStateSave;
     private flushStateSave;
 }
-export {};

package/dist/sdk/inline-sdk-client.js

@@ -1,4 +1,4 @@
-import { GetChatInput, GetMeInput, GetUpdatesInput, GetUpdatesResult_ResultType, GetUpdatesStateInput, InputPeer, MessageEntities, MessageSendMode, Method, UpdateBucket, UpdateComposeAction_ComposeAction, } from "@inline-chat/protocol/core";
+import { GetChatInput, GetMeInput, GetUpdatesInput, GetUpdatesResult_ResultType, GetUpdatesStateInput, InputPeer, MessageSendMode, Method, UpdateBucket, UpdateComposeAction_ComposeAction, } from "@inline-chat/protocol/core";
 import { asInlineId } from "../ids.js";
 import { AsyncChannel } from "../utils/async-channel.js";
 import { ProtocolClient } from "../realtime/protocol-client.js";
@@ -8,6 +8,10 @@ import { noopLogger } from "./logger.js";
 import { getSdkVersion } from "./sdk-version.js";
 const nowSeconds = () => BigInt(Math.floor(Date.now() / 1000));
 const sdkLayer = 1;
+const defaultApiBaseUrl = "https://api.inline.chat";
+const defaultVideoWidth = 1280;
+const defaultVideoHeight = 720;
+const defaultVideoDuration = 1;
 function extractFirstMessageId(updates) {
     for (const update of updates ?? []) {
         if (update.update.oneofKind === "newMessage") {
@@ -21,6 +25,8 @@ function extractFirstMessageId(updates) {
 export class InlineSdkClient {
     options;
     log;
+    httpBaseUrl;
+    fetchImpl;
     transport;
     protocol;
     eventStream = new AsyncChannel();
@@ -35,8 +41,9 @@ export class InlineSdkClient {
     constructor(options) {
         this.options = options;
         this.log = options.logger ?? noopLogger;
-        const baseUrl = options.baseUrl ?? "https://api.inline.chat";
-        const url = resolveRealtimeUrl(baseUrl);
+        this.httpBaseUrl = normalizeHttpBaseUrl(options.baseUrl ?? defaultApiBaseUrl);
+        this.fetchImpl = options.fetch ?? fetch;
+        const url = resolveRealtimeUrl(this.httpBaseUrl);
         this.transport = options.transport ?? new WebSocketTransport({ url, logger: options.logger });
         this.protocol = new ProtocolClient({
             transport: this.transport,
@@ -46,6 +53,7 @@ export class InlineSdkClient {
                 clientVersion: getSdkVersion(),
             }),
             logger: options.logger,
+            defaultRpcTimeoutMs: options.rpcTimeoutMs,
         });
         void this.startListeners();
     }
@@ -143,12 +151,24 @@ export class InlineSdkClient {
         if (params.entities != null && params.parseMarkdown != null) {
             throw new Error("sendMessage: provide either `entities` or `parseMarkdown`, not both");
         }
+        const hasText = typeof params.text === "string" && params.text.length > 0;
+        if (!hasText && params.media == null) {
+            throw new Error("sendMessage: provide `text` and/or `media`");
+        }
+        if (params.parseMarkdown != null && !hasText) {
+            throw new Error("sendMessage: `parseMarkdown` requires non-empty `text`");
+        }
+        if (params.entities != null && !hasText) {
+            throw new Error("sendMessage: `entities` requires non-empty `text`");
+        }
         const peerId = this.inputPeerFromTarget(params, "sendMessage");
+        const media = params.media != null ? toInputMedia(params.media) : undefined;
         const result = await this.invoke(Method.SEND_MESSAGE, {
             oneofKind: "sendMessage",
             sendMessage: {
                 peerId,
-                message: params.text,
+                ...(hasText ? { message: params.text } : {}),
+                ...(media != null ? { media } : {}),
                 ...(params.replyToMsgId != null ? { replyToMsgId: asInlineId(params.replyToMsgId, "replyToMsgId") } : {}),
                 ...(params.parseMarkdown != null ? { parseMarkdown: params.parseMarkdown } : {}),
                 ...(params.entities != null ? { entities: params.entities } : {}),
@@ -158,6 +178,59 @@ export class InlineSdkClient {
         const messageId = extractFirstMessageId(result.sendMessage.updates);
         return { messageId };
     }
+    async uploadFile(params) {
+        const form = new FormData();
+        form.set("type", params.type);
+        const fileName = normalizeUploadFileName(params.fileName, params.type);
+        const fileContentType = resolveUploadContentType(params.type, params.contentType);
+        form.set("file", toBlob(params.file, fileContentType), fileName);
+        if (params.thumbnail != null) {
+            const thumbnailName = normalizeUploadFileName(params.thumbnailFileName, "photo");
+            const thumbnailContentType = resolveUploadContentType("photo", params.thumbnailContentType);
+            form.set("thumbnail", toBlob(params.thumbnail, thumbnailContentType), thumbnailName);
+        }
+        if (params.type === "video") {
+            const width = normalizePositiveInt(params.width, "width") ?? defaultVideoWidth;
+            const height = normalizePositiveInt(params.height, "height") ?? defaultVideoHeight;
+            const duration = normalizePositiveInt(params.duration, "duration") ?? defaultVideoDuration;
+            form.set("width", String(width));
+            form.set("height", String(height));
+            form.set("duration", String(duration));
+        }
+        const response = await this.fetchImpl(new URL("uploadFile", `${this.httpBaseUrl}/`), {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.options.token}`,
+            },
+            body: form,
+        });
+        const payload = await parseJsonResponse(response);
+        if (!response.ok) {
+            const detail = describeUploadFailure(payload);
+            throw new Error(`uploadFile: request failed with status ${response.status}${detail ? ` (${detail})` : ""}`);
+        }
+        if (!isRecord(payload) || payload.ok !== true) {
+            const detail = describeUploadFailure(payload);
+            throw new Error(`uploadFile: API error${detail ? ` (${detail})` : ""}`);
+        }
+        const result = payload.result;
+        if (!isRecord(result)) {
+            throw new Error("uploadFile: malformed success payload");
+        }
+        const fileUniqueId = typeof result.fileUniqueId === "string" ? result.fileUniqueId.trim() : "";
+        if (!fileUniqueId) {
+            throw new Error("uploadFile: response missing fileUniqueId");
+        }
+        const photoId = parseOptionalBigInt(result.photoId, "photoId");
+        const videoId = parseOptionalBigInt(result.videoId, "videoId");
+        const documentId = parseOptionalBigInt(result.documentId, "documentId");
+        return {
+            fileUniqueId,
+            ...(photoId != null ? { photoId } : {}),
+            ...(videoId != null ? { videoId } : {}),
+            ...(documentId != null ? { documentId } : {}),
+        };
+    }
     async sendTyping(params) {
         const peerId = InputPeer.create({
             type: { oneofKind: "chat", chat: { chatId: asInlineId(params.chatId, "chatId") } },
@@ -530,6 +603,138 @@ export class InlineSdkClient {
         await this.saveInFlight;
     }
 }
+function toInputMedia(media) {
+    switch (media.kind) {
+        case "photo":
+            return {
+                media: {
+                    oneofKind: "photo",
+                    photo: {
+                        photoId: asInlineId(media.photoId, "photoId"),
+                    },
+                },
+            };
+        case "video":
+            return {
+                media: {
+                    oneofKind: "video",
+                    video: {
+                        videoId: asInlineId(media.videoId, "videoId"),
+                    },
+                },
+            };
+        case "document":
+            return {
+                media: {
+                    oneofKind: "document",
+                    document: {
+                        documentId: asInlineId(media.documentId, "documentId"),
+                    },
+                },
+            };
+    }
+}
+function normalizeHttpBaseUrl(baseUrl) {
+    const url = new URL(baseUrl);
+    const path = url.pathname.replace(/\/+$/, "");
+    url.pathname = path || "/";
+    return url.toString().replace(/\/$/, "");
+}
+function normalizeUploadFileName(raw, type) {
+    const trimmed = raw?.trim();
+    if (trimmed)
+        return trimmed;
+    switch (type) {
+        case "photo":
+            return "photo.jpg";
+        case "video":
+            return "video.mp4";
+        case "document":
+            return "document.bin";
+    }
+}
+function resolveUploadContentType(type, explicit) {
+    const trimmed = explicit?.trim();
+    if (trimmed)
+        return trimmed;
+    switch (type) {
+        case "photo":
+            return "image/jpeg";
+        case "video":
+            return "video/mp4";
+        case "document":
+            return "application/octet-stream";
+    }
+}
+function toBlob(input, type) {
+    if (input instanceof Blob) {
+        return input.type === type ? input : new Blob([input], { type });
+    }
+    return new Blob([input], { type });
+}
+function normalizePositiveInt(value, field) {
+    if (value == null)
+        return undefined;
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`uploadFile: ${field} must be a positive integer`);
+    }
+    return value;
+}
+async function parseJsonResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("application/json")) {
+        const text = await response.text();
+        return text;
+    }
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeUploadFailure(payload) {
+    if (typeof payload === "string") {
+        const trimmed = payload.trim();
+        return trimmed ? trimmed : "";
+    }
+    if (!isRecord(payload))
+        return "";
+    const description = typeof payload.description === "string" ? payload.description.trim() : "";
+    if (description)
+        return description;
+    const error = typeof payload.error === "string" ? payload.error.trim() : "";
+    if (error)
+        return error;
+    return "";
+}
+function parseOptionalBigInt(value, field) {
+    if (value == null)
+        return undefined;
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {
+            throw new Error(`uploadFile: invalid ${field} in response`);
+        }
+        return BigInt(value);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return undefined;
+        try {
+            return BigInt(trimmed);
+        }
+        catch {
+            throw new Error(`uploadFile: invalid ${field} in response`);
+        }
+    }
+    throw new Error(`uploadFile: invalid ${field} in response`);
+}
 const resolveRealtimeUrl = (baseUrl) => {
     const url = new URL(baseUrl);
     const isSecure = url.protocol === "https:";

package/dist/sdk/types.d.ts

@@ -1,14 +1,65 @@
-import type { Message, Peer, Reaction, RpcCall, RpcResult, Update, UpdateBucket, UpdatesPayload } from "@inline-chat/protocol/core";
-import type { InlineId } from "../ids.js";
+import type { Message, MessageEntities, Peer, Reaction, RpcCall, RpcResult, Update, UpdateBucket, UpdatesPayload } from "@inline-chat/protocol/core";
+import type { InlineId, InlineIdLike } from "../ids.js";
 import type { InlineUnixSeconds } from "../time.js";
 import type { InlineSdkLogger } from "./logger.js";
 import type { Transport } from "../realtime/transport.js";
 export type InlineSdkClientOptions = {
     baseUrl?: string;
     token: string;
+    rpcTimeoutMs?: number | null;
     logger?: InlineSdkLogger;
     state?: InlineSdkStateStore;
     transport?: Transport;
+    fetch?: typeof fetch;
+};
+export type InlineSdkSendMessageMedia = {
+    kind: "photo";
+    photoId: InlineIdLike;
+} | {
+    kind: "video";
+    videoId: InlineIdLike;
+} | {
+    kind: "document";
+    documentId: InlineIdLike;
+};
+export type InlineSdkSendMessageParams = {
+    chatId: InlineIdLike;
+    userId?: never;
+    text?: string;
+    media?: InlineSdkSendMessageMedia;
+    replyToMsgId?: InlineIdLike;
+    parseMarkdown?: boolean;
+    sendMode?: "silent";
+    entities?: MessageEntities;
+} | {
+    userId: InlineIdLike;
+    chatId?: never;
+    text?: string;
+    media?: InlineSdkSendMessageMedia;
+    replyToMsgId?: InlineIdLike;
+    parseMarkdown?: boolean;
+    sendMode?: "silent";
+    entities?: MessageEntities;
+};
+export type InlineSdkBinaryInput = Blob | Uint8Array | ArrayBuffer | SharedArrayBuffer;
+export type InlineSdkUploadFileType = "photo" | "video" | "document";
+export type InlineSdkUploadFileParams = {
+    type: InlineSdkUploadFileType;
+    file: InlineSdkBinaryInput;
+    fileName?: string;
+    contentType?: string;
+    thumbnail?: InlineSdkBinaryInput;
+    thumbnailFileName?: string;
+    thumbnailContentType?: string;
+    width?: number;
+    height?: number;
+    duration?: number;
+};
+export type InlineSdkUploadFileResult = {
+    fileUniqueId: string;
+    photoId?: bigint;
+    videoId?: bigint;
+    documentId?: bigint;
 };
 export type InlineInboundEvent = {
     kind: "message.new";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inline-chat/realtime-sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "private": false,
   "type": "module",
   "files": [