@session.js/types 1.0.14 → 1.0.15

package/README.md

@@ -1,6 +1,6 @@
 # @session.js/types
 
-A special package that holds TypeScript definitions and enums shared internally for developing your own @session.js/client modular parts.
+Session Messenger messages schemas, TypeScript definitions and enums used by @session.js/client
 
 To build your own Storage adapter, use:
 

package/dist/envelope.d.ts

@@ -1,4 +1,4 @@
-import type { SignalService } from "./signal-bindings/index.js";
+import type { SignalService } from "./signal-bindings";
 export interface EnvelopePlus extends Omit<SignalService.Envelope, "toJSON"> {
     senderIdentity: string;
     receivedAt: number;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { SnodeNamespaces } from "./namespaces.js";
-export type { Network } from "./network/index.js";
-export type { Storage } from "./storage/index.js";
+export { SnodeNamespaces } from "./namespaces";
+export type { Network } from "./network";
+export type { Storage } from "./storage";

package/dist/index.js

@@ -1 +1 @@
-export { SnodeNamespaces } from "./namespaces.js";
+export { SnodeNamespaces } from "./namespaces";

package/dist/messages/expirable-message.d.ts

@@ -0,0 +1,17 @@
+import { ContentMessage, type MessageParams } from "./signal-message";
+import { SignalService } from "../signal-bindings";
+import type { DisappearingMessageType } from "../disappearing-message";
+export interface ExpirableMessageParams extends MessageParams {
+    expirationType: DisappearingMessageType | null;
+    expireTimer: number | null;
+}
+export declare class ExpirableMessage extends ContentMessage {
+    readonly expirationType: DisappearingMessageType | null;
+    /** in seconds, 0 means no expiration */
+    readonly expireTimer: number | null;
+    constructor(params: ExpirableMessageParams);
+    contentProto(): SignalService.Content;
+    dataProto(): SignalService.DataMessage;
+    getDisappearingMessageType(): DisappearingMessageType | undefined;
+    ttl(): number;
+}

package/dist/messages/expirable-message.js

@@ -0,0 +1,52 @@
+import { DURATION, TTL_DEFAULT } from "@session.js/consts";
+import { ContentMessage } from "./signal-message";
+import { SignalService } from "../signal-bindings";
+export class ExpirableMessage extends ContentMessage {
+    expirationType;
+    /** in seconds, 0 means no expiration */
+    expireTimer;
+    constructor(params) {
+        super({
+            timestamp: params.timestamp,
+            identifier: params.identifier,
+        });
+        this.expirationType = params.expirationType;
+        this.expireTimer = params.expireTimer;
+    }
+    contentProto() {
+        return new SignalService.Content({
+            // TODO legacy messages support will be removed in a future release
+            expirationType: this.expirationType === "deleteAfterSend"
+                ? SignalService.Content.ExpirationType.DELETE_AFTER_SEND
+                : this.expirationType === "deleteAfterRead"
+                    ? SignalService.Content.ExpirationType.DELETE_AFTER_READ
+                    : this.expirationType === "unknown"
+                        ? SignalService.Content.ExpirationType.UNKNOWN
+                        : undefined,
+            expirationTimer: this.expireTimer && this.expireTimer > -1 ? this.expireTimer : undefined,
+        });
+    }
+    dataProto() {
+        return new SignalService.DataMessage({
+            // TODO legacy messages support will be removed in a future release
+            expireTimer: (this.expirationType === "unknown" || !this.expirationType) &&
+                this.expireTimer &&
+                this.expireTimer > -1
+                ? this.expireTimer
+                : undefined,
+        });
+    }
+    getDisappearingMessageType() {
+        return this.expirationType || undefined;
+    }
+    ttl() {
+        switch (this.expirationType) {
+            case "deleteAfterSend":
+                return this.expireTimer ? this.expireTimer * DURATION.SECONDS : TTL_DEFAULT.CONTENT_MESSAGE;
+            case "deleteAfterRead":
+                return TTL_DEFAULT.CONTENT_MESSAGE;
+            default:
+                return TTL_DEFAULT.CONTENT_MESSAGE;
+        }
+    }
+}

package/dist/messages/schema/configuration-message.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @deprecated — use SharedConfigMessage
+ */
+import { ContentMessage, type MessageParams } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+interface ConfigurationMessageParams extends MessageParams {
+    activeClosedGroups: Array<ConfigurationMessageClosedGroup>;
+    activeOpenGroups: Array<string>;
+    displayName: string;
+    profilePicture?: string;
+    profileKey?: Uint8Array;
+    contacts: Array<ConfigurationMessageContact>;
+}
+export declare class ConfigurationMessage extends ContentMessage {
+    readonly activeClosedGroups: Array<ConfigurationMessageClosedGroup>;
+    readonly activeOpenGroups: Array<string>;
+    readonly displayName: string;
+    readonly profilePicture?: string;
+    readonly profileKey?: Uint8Array;
+    readonly contacts: Array<ConfigurationMessageContact>;
+    constructor(params: ConfigurationMessageParams);
+    contentProto(): SignalService.Content;
+    protected configurationProto(): SignalService.ConfigurationMessage;
+    private mapClosedGroupsObjectToProto;
+    private mapContactsObjectToProto;
+}
+export declare class ConfigurationMessageContact {
+    publicKey: Uint8Array;
+    displayName: string;
+    profilePictureURL?: string;
+    profileKey?: Uint8Array;
+    isApproved?: boolean;
+    isBlocked?: boolean;
+    didApproveMe?: boolean;
+    constructor({ publicKey, displayName, profilePictureURL, profileKey, isApproved, isBlocked, didApproveMe, }: {
+        publicKey: Uint8Array;
+        displayName: string;
+        profilePictureURL?: string;
+        profileKey?: Uint8Array;
+        isApproved?: boolean;
+        isBlocked?: boolean;
+        didApproveMe?: boolean;
+    });
+    toProto(): SignalService.ConfigurationMessage.Contact;
+}
+export declare class ConfigurationMessageClosedGroup {
+    publicKey: Uint8Array;
+    name: string;
+    encryptionKeyPair: {
+        privateKeyData: Uint8Array;
+        publicKeyData: Uint8Array;
+    };
+    members: Array<string>;
+    admins: Array<string>;
+    constructor({ publicKey, name, encryptionKeyPair, members, admins, }: {
+        publicKey: Uint8Array;
+        name: string;
+        encryptionKeyPair: {
+            privateKeyData: Uint8Array;
+            publicKeyData: Uint8Array;
+        };
+        members: Array<string>;
+        admins: Array<string>;
+    });
+    toProto(): SignalService.ConfigurationMessage.ClosedGroup;
+}
+export {};

package/dist/messages/schema/configuration-message.js

@@ -0,0 +1,172 @@
+/**
+ * @deprecated — use SharedConfigMessage
+ */
+import { SessionValidationError, SessionValidationErrorCode } from "@session.js/errors";
+import { ContentMessage } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+const hexToBytes = (hex) => {
+    return Uint8Array.from(hex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+};
+export class ConfigurationMessage extends ContentMessage {
+    activeClosedGroups;
+    activeOpenGroups;
+    displayName;
+    profilePicture;
+    profileKey;
+    contacts;
+    constructor(params) {
+        super({ timestamp: params.timestamp, identifier: params.identifier });
+        this.activeClosedGroups = params.activeClosedGroups;
+        this.activeOpenGroups = params.activeOpenGroups;
+        this.displayName = params.displayName;
+        this.profilePicture = params.profilePicture;
+        this.profileKey = params.profileKey;
+        this.contacts = params.contacts;
+        if (!this.activeClosedGroups) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "closed group must be set",
+            });
+        }
+        if (!this.activeOpenGroups) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "open group must be set",
+            });
+        }
+        if (!this.displayName || !this.displayName?.length) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "displayName must be set",
+            });
+        }
+        if (this.profilePicture && typeof this.profilePicture !== "string") {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "profilePicture set but not an Uin8Array",
+            });
+        }
+        if (this.profileKey && !(this.profileKey instanceof Uint8Array)) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "profileKey set but not an Uin8Array",
+            });
+        }
+        if (!this.contacts) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "contacts must be set",
+            });
+        }
+    }
+    contentProto() {
+        return new SignalService.Content({
+            configurationMessage: this.configurationProto(),
+        });
+    }
+    configurationProto() {
+        return new SignalService.ConfigurationMessage({
+            closedGroups: this.mapClosedGroupsObjectToProto(this.activeClosedGroups),
+            openGroups: this.activeOpenGroups,
+            displayName: this.displayName,
+            profilePicture: this.profilePicture,
+            profileKey: this.profileKey,
+            contacts: this.mapContactsObjectToProto(this.contacts),
+        });
+    }
+    mapClosedGroupsObjectToProto(closedGroups) {
+        return (closedGroups || []).map((m) => m.toProto());
+    }
+    mapContactsObjectToProto(contacts) {
+        return (contacts || []).map((m) => m.toProto());
+    }
+}
+export class ConfigurationMessageContact {
+    publicKey;
+    displayName;
+    profilePictureURL;
+    profileKey;
+    isApproved;
+    isBlocked;
+    didApproveMe;
+    constructor({ publicKey, displayName, profilePictureURL, profileKey, isApproved, isBlocked, didApproveMe, }) {
+        this.publicKey = publicKey;
+        this.displayName = displayName;
+        this.profilePictureURL = profilePictureURL;
+        this.profileKey = profileKey;
+        this.isApproved = isApproved;
+        this.isBlocked = isBlocked;
+        this.didApproveMe = didApproveMe;
+        if (this.displayName?.length === 0) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "displayName must be set or undefined",
+            });
+        }
+        if (this.profilePictureURL !== undefined && this.profilePictureURL?.length === 0) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "profilePictureURL must either undefined or not empty",
+            });
+        }
+        if (this.profileKey !== undefined && this.profileKey?.length === 0) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "profileKey must either undefined or not empty",
+            });
+        }
+    }
+    toProto() {
+        return new SignalService.ConfigurationMessage.Contact({
+            publicKey: this.publicKey,
+            name: this.displayName,
+            profilePicture: this.profilePictureURL,
+            profileKey: this.profileKey,
+            isApproved: this.isApproved,
+            isBlocked: this.isBlocked,
+            didApproveMe: this.didApproveMe,
+        });
+    }
+}
+export class ConfigurationMessageClosedGroup {
+    publicKey;
+    name;
+    encryptionKeyPair;
+    members;
+    admins;
+    constructor({ publicKey, name, encryptionKeyPair, members, admins, }) {
+        this.publicKey = publicKey;
+        this.name = name;
+        this.encryptionKeyPair = encryptionKeyPair;
+        this.members = members;
+        this.admins = admins;
+        if (!encryptionKeyPair?.privateKeyData?.byteLength ||
+            !encryptionKeyPair?.publicKeyData?.byteLength) {
+            throw new Error("Encryption key pair looks invalid");
+        }
+        if (!this.name?.length) {
+            throw new Error("name must be set");
+        }
+        if (!this.members?.length) {
+            throw new Error("members must be set");
+        }
+        if (!this.admins?.length) {
+            throw new Error("admins must be set");
+        }
+        if (this.admins.some((a) => !this.members.includes(a))) {
+            throw new Error("some admins are not members");
+        }
+    }
+    toProto() {
+        return new SignalService.ConfigurationMessage.ClosedGroup({
+            publicKey: this.publicKey,
+            name: this.name,
+            encryptionKeyPair: {
+                publicKey: this.encryptionKeyPair.publicKeyData,
+                privateKey: this.encryptionKeyPair.privateKeyData,
+            },
+            members: this.members.map(hexToBytes),
+            admins: this.admins.map(hexToBytes),
+        });
+    }
+}

package/dist/messages/schema/conversation-request-message.d.ts

@@ -0,0 +1,13 @@
+import { ContentMessage, type MessageParams } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+import { type Profile } from "../../profile";
+export interface MessageRequestResponseParams extends MessageParams {
+    profile?: Profile;
+}
+export declare class MessageRequestResponse extends ContentMessage {
+    private readonly profileKey?;
+    private readonly profile?;
+    constructor(params: MessageRequestResponseParams);
+    contentProto(): SignalService.Content;
+    messageRequestResponseProto(): SignalService.MessageRequestResponse;
+}

package/dist/messages/schema/conversation-request-message.js

@@ -0,0 +1,30 @@
+import { ContentMessage } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+import { serializeProfile } from "../../profile";
+// Request is always Approved
+export class MessageRequestResponse extends ContentMessage {
+    profileKey;
+    profile;
+    constructor(params) {
+        super({
+            timestamp: params.timestamp,
+        });
+        if (params.profile) {
+            const profile = serializeProfile(params.profile);
+            this.profile = profile.lokiProfile;
+            this.profileKey = profile.profileKey;
+        }
+    }
+    contentProto() {
+        return new SignalService.Content({
+            messageRequestResponse: this.messageRequestResponseProto(),
+        });
+    }
+    messageRequestResponseProto() {
+        return new SignalService.MessageRequestResponse({
+            isApproved: true,
+            profileKey: this.profileKey?.length ? this.profileKey : undefined,
+            profile: this.profile,
+        });
+    }
+}

package/dist/messages/schema/data-extraction-message.d.ts

@@ -0,0 +1,16 @@
+import { ExpirableMessage, type ExpirableMessageParams } from "../expirable-message";
+import { SignalService } from "../../signal-bindings";
+interface DataExtractionNotificationMessageParams extends ExpirableMessageParams {
+    action: SignalService.DataExtractionNotification.Type;
+    /** For SCREENSHOT, timestamp when screenshot was taken
+     * For MEDIA_SAVED, message with attachment's timestamp */
+    timestamp: number;
+}
+export declare class DataExtractionNotificationMessage extends ExpirableMessage {
+    readonly timestamp: number;
+    readonly action: SignalService.DataExtractionNotification.Type;
+    constructor(params: DataExtractionNotificationMessageParams);
+    contentProto(): SignalService.Content;
+    protected dataExtractionProto(): SignalService.DataExtractionNotification;
+}
+export {};

package/dist/messages/schema/data-extraction-message.js

@@ -0,0 +1,22 @@
+import { ExpirableMessage } from "../expirable-message";
+import { SignalService } from "../../signal-bindings";
+export class DataExtractionNotificationMessage extends ExpirableMessage {
+    timestamp;
+    action;
+    constructor(params) {
+        super(params);
+        this.timestamp = params.timestamp;
+        this.action = params.action;
+    }
+    contentProto() {
+        const content = super.contentProto();
+        content.dataExtractionNotification = this.dataExtractionProto();
+        return content;
+    }
+    dataExtractionProto() {
+        return new SignalService.DataExtractionNotification({
+            type: this.action,
+            timestamp: this.timestamp,
+        });
+    }
+}

package/dist/messages/schema/delete-message.d.ts

@@ -0,0 +1,13 @@
+import { ContentMessage, type MessageParams } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+interface UnsendMessageParams extends MessageParams {
+    timestamp: number;
+    author: string;
+}
+export declare class UnsendMessage extends ContentMessage {
+    private readonly author;
+    constructor(params: UnsendMessageParams);
+    contentProto(): SignalService.Content;
+    unsendProto(): SignalService.Unsend;
+}
+export {};

package/dist/messages/schema/delete-message.js

@@ -0,0 +1,20 @@
+import { ContentMessage } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+export class UnsendMessage extends ContentMessage {
+    author;
+    constructor(params) {
+        super({ timestamp: params.timestamp, author: params.author });
+        this.author = params.author;
+    }
+    contentProto() {
+        return new SignalService.Content({
+            unsendMessage: this.unsendProto(),
+        });
+    }
+    unsendProto() {
+        return new SignalService.Unsend({
+            timestamp: this.timestamp,
+            author: this.author,
+        });
+    }
+}

package/dist/messages/schema/index.d.ts

@@ -0,0 +1,8 @@
+export { VisibleMessage } from "./visible-message";
+export { ConfigurationMessage } from "./configuration-message";
+export { MessageRequestResponse } from "./conversation-request-message";
+export { DataExtractionNotificationMessage } from "./data-extraction-message";
+export { UnsendMessage } from "./delete-message";
+export { ReadReceiptMessage } from "./read-receipt-message";
+export { SharedConfigMessage } from "./shared-config-message";
+export { TypingMessage } from "./typing-indicator-message";

package/dist/messages/schema/index.js

@@ -0,0 +1,8 @@
+export { VisibleMessage } from "./visible-message";
+export { ConfigurationMessage } from "./configuration-message";
+export { MessageRequestResponse } from "./conversation-request-message";
+export { DataExtractionNotificationMessage } from "./data-extraction-message";
+export { UnsendMessage } from "./delete-message";
+export { ReadReceiptMessage } from "./read-receipt-message";
+export { SharedConfigMessage } from "./shared-config-message";
+export { TypingMessage } from "./typing-indicator-message";

package/dist/messages/schema/read-receipt-message.d.ts

@@ -0,0 +1,16 @@
+import { ContentMessage, type MessageParams } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+interface ReceiptMessageParams extends MessageParams {
+    timestamps: Array<number>;
+}
+export declare abstract class ReceiptMessage extends ContentMessage {
+    readonly timestamps: Array<number>;
+    constructor({ timestamp, identifier, timestamps }: ReceiptMessageParams);
+    abstract getReceiptType(): SignalService.ReceiptMessage.Type;
+    contentProto(): SignalService.Content;
+    protected receiptProto(): SignalService.ReceiptMessage;
+}
+export declare class ReadReceiptMessage extends ReceiptMessage {
+    getReceiptType(): SignalService.ReceiptMessage.Type;
+}
+export {};

package/dist/messages/schema/read-receipt-message.js

@@ -0,0 +1,25 @@
+import { ContentMessage } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+export class ReceiptMessage extends ContentMessage {
+    timestamps;
+    constructor({ timestamp, identifier, timestamps }) {
+        super({ timestamp, identifier });
+        this.timestamps = timestamps;
+    }
+    contentProto() {
+        return new SignalService.Content({
+            receiptMessage: this.receiptProto(),
+        });
+    }
+    receiptProto() {
+        return new SignalService.ReceiptMessage({
+            type: this.getReceiptType(),
+            timestamp: this.timestamps,
+        });
+    }
+}
+export class ReadReceiptMessage extends ReceiptMessage {
+    getReceiptType() {
+        return SignalService.ReceiptMessage.Type.READ;
+    }
+}

package/dist/messages/schema/shared-config-message.d.ts

@@ -0,0 +1,18 @@
+import Long from "long";
+import { ContentMessage, type MessageParams } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+interface SharedConfigParams extends MessageParams {
+    seqno: Long;
+    kind: SignalService.SharedConfigMessage.Kind;
+    data: Uint8Array;
+}
+export declare class SharedConfigMessage extends ContentMessage {
+    readonly seqno: Long;
+    readonly kind: SignalService.SharedConfigMessage.Kind;
+    readonly data: Uint8Array;
+    constructor(params: SharedConfigParams);
+    contentProto(): SignalService.Content;
+    ttl(): number;
+    protected sharedConfigProto(): SignalService.SharedConfigMessage;
+}
+export {};

package/dist/messages/schema/shared-config-message.js

@@ -0,0 +1,30 @@
+import Long from "long";
+import { TTL_DEFAULT } from "@session.js/consts";
+import { ContentMessage } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+export class SharedConfigMessage extends ContentMessage {
+    seqno;
+    kind;
+    data;
+    constructor(params) {
+        super({ timestamp: params.timestamp, identifier: params.identifier });
+        this.data = params.data;
+        this.kind = params.kind;
+        this.seqno = params.seqno;
+    }
+    contentProto() {
+        return new SignalService.Content({
+            sharedConfigMessage: this.sharedConfigProto(),
+        });
+    }
+    ttl() {
+        return TTL_DEFAULT.CONFIG_MESSAGE;
+    }
+    sharedConfigProto() {
+        return new SignalService.SharedConfigMessage({
+            data: this.data,
+            kind: this.kind,
+            seqno: this.seqno,
+        });
+    }
+}

package/dist/messages/schema/typing-indicator-message.d.ts

@@ -0,0 +1,15 @@
+import { ContentMessage, type MessageParams } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+interface TypingMessageParams extends MessageParams {
+    isTyping: boolean;
+    typingTimestamp?: number;
+}
+export declare class TypingMessage extends ContentMessage {
+    readonly isTyping: boolean;
+    readonly typingTimestamp?: number;
+    constructor(params: TypingMessageParams);
+    ttl(): number;
+    contentProto(): SignalService.Content;
+    protected typingProto(): SignalService.TypingMessage;
+}
+export {};

package/dist/messages/schema/typing-indicator-message.js

@@ -0,0 +1,29 @@
+import * as Constants from "@session.js/consts";
+import { ContentMessage } from "../signal-message";
+import { SignalService } from "../../signal-bindings";
+export class TypingMessage extends ContentMessage {
+    isTyping;
+    typingTimestamp;
+    constructor(params) {
+        super({ timestamp: params.timestamp, identifier: params.identifier });
+        this.isTyping = params.isTyping;
+        this.typingTimestamp = params.typingTimestamp;
+    }
+    ttl() {
+        return Constants.TTL_DEFAULT.TYPING_MESSAGE;
+    }
+    contentProto() {
+        return new SignalService.Content({
+            typingMessage: this.typingProto(),
+        });
+    }
+    typingProto() {
+        const ACTION_ENUM = SignalService.TypingMessage.Action;
+        const action = this.isTyping ? ACTION_ENUM.STARTED : ACTION_ENUM.STOPPED;
+        const finalTimestamp = this.typingTimestamp || Date.now();
+        const typingMessage = new SignalService.TypingMessage();
+        typingMessage.action = action;
+        typingMessage.timestamp = finalTimestamp;
+        return typingMessage;
+    }
+}

package/dist/messages/schema/visible-message.d.ts

@@ -0,0 +1,75 @@
+import { ExpirableMessage, type ExpirableMessageParams } from "../expirable-message";
+import { type Reaction } from "../../reactions";
+import { type Profile } from "../../profile";
+import { SignalService } from "../../signal-bindings";
+interface AttachmentPointerCommon {
+    contentType?: string;
+    key?: Uint8Array;
+    size?: number;
+    thumbnail?: Uint8Array;
+    digest?: Uint8Array;
+    fileName?: string;
+    flags?: number;
+    width?: number;
+    height?: number;
+    caption?: string;
+}
+export interface AttachmentPointer extends AttachmentPointerCommon {
+    url?: string;
+    id?: number;
+}
+export interface AttachmentPointerWithUrl extends AttachmentPointerCommon {
+    url: string;
+    id: number;
+}
+export interface Preview {
+    url: string;
+    title?: string;
+    image?: AttachmentPointer;
+}
+export interface PreviewWithAttachmentUrl {
+    url: string;
+    id: number;
+    title?: string;
+    image?: AttachmentPointerWithUrl;
+}
+interface QuotedAttachmentCommon {
+    contentType?: string;
+    fileName?: string;
+}
+export interface QuotedAttachment extends QuotedAttachmentCommon {
+    thumbnail?: AttachmentPointer;
+}
+export interface QuotedAttachmentWithUrl extends QuotedAttachmentCommon {
+    thumbnail?: AttachmentPointerWithUrl | QuotedAttachment;
+}
+export interface Quote {
+    id: number;
+    author: string;
+    text?: string;
+    attachments?: Array<QuotedAttachmentWithUrl>;
+}
+export interface VisibleMessageParams extends ExpirableMessageParams {
+    attachments?: Array<AttachmentPointerWithUrl>;
+    body?: string;
+    quote?: Quote;
+    profile?: Profile;
+    preview?: Array<PreviewWithAttachmentUrl>;
+    reaction?: Reaction;
+    syncTarget?: string;
+}
+export declare class VisibleMessage extends ExpirableMessage {
+    readonly reaction?: Reaction;
+    private readonly attachments?;
+    private readonly body?;
+    private readonly quote?;
+    private readonly profileKey?;
+    private readonly profile?;
+    private readonly preview?;
+    private readonly syncTarget?;
+    constructor(params: VisibleMessageParams);
+    contentProto(): SignalService.Content;
+    dataProto(): SignalService.DataMessage;
+    isEqual(comparator: VisibleMessage): boolean;
+}
+export {};

package/dist/messages/schema/visible-message.js

@@ -0,0 +1,104 @@
+import { ExpirableMessage } from "../expirable-message";
+import { ReactionAction } from "../../reactions";
+import { serializeProfile } from "../../profile";
+import { SignalService } from "../../signal-bindings";
+export class VisibleMessage extends ExpirableMessage {
+    reaction;
+    attachments;
+    body;
+    quote;
+    profileKey;
+    profile;
+    preview;
+    syncTarget;
+    constructor(params) {
+        super({
+            timestamp: params.timestamp,
+            identifier: params.identifier,
+            expirationType: params.expirationType,
+            expireTimer: params.expireTimer,
+        });
+        this.attachments = params.attachments;
+        this.body = params.body;
+        this.quote = params.quote;
+        if (params.profile) {
+            const profile = serializeProfile(params.profile);
+            this.profile = profile.lokiProfile;
+            this.profileKey = profile.profileKey;
+        }
+        this.preview = params.preview;
+        this.reaction = params.reaction;
+        this.syncTarget = params.syncTarget;
+    }
+    contentProto() {
+        const content = super.contentProto();
+        content.dataMessage = this.dataProto();
+        return content;
+    }
+    dataProto() {
+        const dataMessage = super.dataProto();
+        if (this.body) {
+            dataMessage.body = this.body;
+        }
+        dataMessage.attachments = this.attachments || [];
+        if (this.preview) {
+            dataMessage.preview = this.preview;
+        }
+        if (this.reaction) {
+            dataMessage.reaction = {
+                ...this.reaction,
+                action: this.reaction.action === ReactionAction.REACT
+                    ? SignalService.DataMessage.Reaction.Action.REACT
+                    : SignalService.DataMessage.Reaction.Action.REMOVE,
+            };
+        }
+        if (this.syncTarget) {
+            dataMessage.syncTarget = this.syncTarget;
+        }
+        if (this.profile) {
+            dataMessage.profile = this.profile;
+        }
+        if (this.profileKey && this.profileKey.length) {
+            dataMessage.profileKey = this.profileKey;
+        }
+        if (this.quote) {
+            dataMessage.quote = new SignalService.DataMessage.Quote();
+            dataMessage.quote.id = this.quote.id;
+            dataMessage.quote.author = this.quote.author;
+            dataMessage.quote.text = this.quote.text;
+            if (this.quote.attachments) {
+                dataMessage.quote.attachments = this.quote.attachments.map((attachment) => {
+                    const quotedAttachment = new SignalService.DataMessage.Quote.QuotedAttachment();
+                    if (attachment.contentType) {
+                        quotedAttachment.contentType = attachment.contentType;
+                    }
+                    if (attachment.fileName) {
+                        quotedAttachment.fileName = attachment.fileName;
+                    }
+                    if (attachment.thumbnail && "id" in attachment.thumbnail) {
+                        quotedAttachment.thumbnail = attachment.thumbnail;
+                    }
+                    return quotedAttachment;
+                });
+            }
+        }
+        if (Array.isArray(this.preview)) {
+            dataMessage.preview = this.preview.map((preview) => {
+                const item = new SignalService.DataMessage.Preview();
+                if (preview.title) {
+                    item.title = preview.title;
+                }
+                if (preview.url) {
+                    item.url = preview.url;
+                }
+                item.image = preview.image || null;
+                return item;
+            });
+        }
+        dataMessage.timestamp = this.timestamp;
+        return dataMessage;
+    }
+    isEqual(comparator) {
+        return this.identifier === comparator.identifier && this.timestamp === comparator.timestamp;
+    }
+}

package/dist/messages/signal-message.d.ts

@@ -0,0 +1,25 @@
+import { SignalService } from "../signal-bindings";
+import { SnodeNamespaces } from "../namespaces";
+export interface MessageParams {
+    timestamp: number;
+    identifier?: string;
+}
+export declare abstract class SignalMessage {
+    readonly timestamp: number;
+    readonly identifier: string;
+    constructor({ timestamp, identifier }: MessageParams);
+}
+export declare abstract class ContentMessage extends SignalMessage {
+    plainTextBuffer(): Uint8Array;
+    ttl(): number;
+    abstract contentProto(): SignalService.Content;
+}
+export type RawMessage = {
+    identifier: string;
+    plainTextBuffer: Uint8Array;
+    recipient: string;
+    ttl: number;
+    encryption: SignalService.Envelope.Type;
+    namespace: SnodeNamespaces;
+};
+export declare function toRawMessage(destinationPubKey: string, message: ContentMessage, namespace: SnodeNamespaces, isGroup?: boolean): RawMessage;

package/dist/messages/signal-message.js

@@ -0,0 +1,47 @@
+import { SessionValidationError, SessionValidationErrorCode } from "@session.js/errors";
+import { SignalService } from "../signal-bindings";
+import { SnodeNamespaces } from "../namespaces";
+export class SignalMessage {
+    timestamp;
+    identifier;
+    constructor({ timestamp, identifier }) {
+        this.timestamp = timestamp;
+        if (identifier && identifier.length === 0) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "Cannot set empty identifier",
+            });
+        }
+        if (!timestamp) {
+            throw new SessionValidationError({
+                code: SessionValidationErrorCode.InvalidOptions,
+                message: "Cannot set undefined timestamp",
+            });
+        }
+        this.identifier = identifier || crypto.randomUUID();
+    }
+}
+export class ContentMessage extends SignalMessage {
+    plainTextBuffer() {
+        return SignalService.Content.encode(this.contentProto()).finish();
+    }
+    ttl() {
+        return 14 * 24 * 60 * 60 * 1000;
+    }
+}
+export function toRawMessage(destinationPubKey, message, namespace, isGroup = false) {
+    const ttl = message.ttl();
+    const plainTextBuffer = message.plainTextBuffer();
+    const encryption = isGroup
+        ? SignalService.Envelope.Type.CLOSED_GROUP_MESSAGE
+        : SignalService.Envelope.Type.SESSION_MESSAGE;
+    const rawMessage = {
+        identifier: message.identifier,
+        plainTextBuffer,
+        recipient: destinationPubKey,
+        ttl,
+        encryption,
+        namespace,
+    };
+    return rawMessage;
+}

package/dist/namespaces.d.ts

@@ -1,4 +1,4 @@
-import type { PickEnum } from "./enums.js";
+import type { PickEnum } from "./enums";
 export declare enum SnodeNamespaces {
     /**
      * This is the namespace anyone can deposit a message for us

package/dist/network/index.d.ts

@@ -1,4 +1,4 @@
-import type { RequestType } from "./request.js";
+import type { RequestType } from "./request";
 export interface Network {
     onRequest(type: RequestType, body: unknown): Promise<unknown>;
 }

package/dist/network/request.d.ts

@@ -1,6 +1,6 @@
-import type { Snode } from "../snode.js";
-import type { RequestNamespace } from "../snode-retrieve.js";
-import type { Swarm } from "../swarm.js";
+import type { Snode } from "../snode";
+import type { RequestNamespace } from "../snode-retrieve";
+import type { Swarm } from "../swarm";
 export declare enum RequestType {
     Store = "/store",
     GetSnodes = "/get_snodes",

package/dist/network/response.d.ts

@@ -1,7 +1,7 @@
-import type { SnodeNamespaces } from "../namespaces.js";
-import type { Snode } from "../snode.js";
-import type { RetrieveMessageItem } from "../snode-retrieve.js";
-import type { Swarm } from "../swarm.js";
+import type { SnodeNamespaces } from "../namespaces";
+import type { Snode } from "../snode";
+import type { RetrieveMessageItem } from "../snode-retrieve";
+import type { Swarm } from "../swarm";
 export type ResponseStore = {
     hash: string;
 };

package/dist/profile.d.ts

@@ -0,0 +1,18 @@
+import { SignalService } from "./signal-bindings";
+export type Profile = {
+    /** Name, displayed instead of your Session ID. Acts like nickname. All unicode characters are accepted except for `ￒ` (0xffd2) which is reserved by Session for mentions. Max length: 64 characters */
+    displayName: string;
+    /** Image, displayed near display name in Session clients. Acts like profile picture. */
+    avatar?: {
+        /** URL to avatar, uploaded to Session file server */
+        url: string;
+        /** 32 bytes key used for avatar encryption */
+        key: Uint8Array;
+    };
+};
+export type SignalILokiProfile = {
+    lokiProfile: SignalService.DataMessage.ILokiProfile | undefined;
+    profileKey: Uint8Array | undefined;
+};
+export declare function serializeProfile(profile: Profile): SignalILokiProfile;
+export declare function deserializeProfile(signalILokiProfile: SignalILokiProfile): Profile;

package/dist/profile.js

@@ -0,0 +1,29 @@
+import { SignalService } from "./signal-bindings";
+export function serializeProfile(profile) {
+    let signalILokiProfile;
+    if (profile.avatar || profile.displayName) {
+        signalILokiProfile = new SignalService.DataMessage.LokiProfile();
+        if (profile.avatar && profile.avatar.url && profile.avatar.key.length) {
+            signalILokiProfile.profilePicture = profile.avatar.url;
+        }
+        if (profile.displayName) {
+            signalILokiProfile.displayName = profile.displayName;
+        }
+    }
+    return {
+        lokiProfile: signalILokiProfile,
+        profileKey: profile.avatar?.key,
+    };
+}
+export function deserializeProfile(signalILokiProfile) {
+    const profile = {
+        displayName: signalILokiProfile.lokiProfile?.displayName || "",
+        avatar: signalILokiProfile.lokiProfile?.profilePicture && signalILokiProfile.profileKey
+            ? {
+                url: signalILokiProfile.lokiProfile.profilePicture,
+                key: signalILokiProfile.profileKey,
+            }
+            : undefined,
+    };
+    return profile;
+}

package/dist/reactions.d.ts

@@ -0,0 +1,10 @@
+export declare enum ReactionAction {
+    REACT = 0,
+    REMOVE = 1
+}
+export interface Reaction {
+    id: number;
+    author: string;
+    emoji: string;
+    action: ReactionAction;
+}

package/dist/reactions.js

@@ -0,0 +1,5 @@
+export var ReactionAction;
+(function (ReactionAction) {
+    ReactionAction[ReactionAction["REACT"] = 0] = "REACT";
+    ReactionAction[ReactionAction["REMOVE"] = 1] = "REMOVE";
+})(ReactionAction || (ReactionAction = {}));

package/dist/signal-bindings/index.d.ts

@@ -1,3 +1,3 @@
 import { signalservice as SignalService } from './compiled';
-import { ProtobufUtils } from './utils.js';
+import { ProtobufUtils } from './utils';
 export { SignalService, ProtobufUtils };

package/dist/signal-bindings/index.js

@@ -1,3 +1,3 @@
 import { signalservice as SignalService } from './compiled';
-import { ProtobufUtils } from './utils.js';
+import { ProtobufUtils } from './utils';
 export { SignalService, ProtobufUtils };

package/dist/snode-retrieve.d.ts

@@ -1,4 +1,4 @@
-import type { SnodeNamespaces } from "./namespaces.js";
+import type { SnodeNamespaces } from "./namespaces";
 export type RetrieveMessageItem = {
     hash: string;
     expiration: number;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@session.js/types",
-	"version": "1.0.14",
-	"description": "A special package that holds TypeScript definitions and enums shared internally and for developing your own @session.js/client modular parts.",
+	"version": "1.0.15",
+	"description": "Session Messenger messages schemas, TypeScript definitions and enums used by @session.js/client",
 	"homepage": "https://git.hloth.dev/session.js/types#readme",
 	"bugs": {
 		"url": "https://git.hloth.dev/session.js/types/issues"
@@ -14,68 +14,6 @@
 	"license": "MIT",
 	"author": "Viktor Shchelochkov <hi@hloth.dev> (https://hloth.dev)",
 	"type": "module",
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		},
-		"./network": {
-			"import": "./dist/network/index.js",
-			"types": "./dist/network/index.d.ts"
-		},
-		"./network/request": {
-			"import": "./dist/network/request.js",
-			"types": "./dist/network/request.d.ts"
-		},
-		"./network/response": {
-			"import": "./dist/network/response.js",
-			"types": "./dist/network/response.d.ts"
-		},
-		"./storage": {
-			"import": "./dist/storage/index.js",
-			"types": "./dist/storage/index.d.ts"
-		},
-		"./signal-bindings": {
-			"import": "./dist/signal-bindings/index.js",
-			"types": "./dist/signal-bindings/index.d.ts"
-		},
-		"./disappearing-message": {
-			"import": "./dist/disappearing-message.js",
-			"types": "./dist/disappearing-message.d.ts"
-		},
-		"./enums": {
-			"import": "./dist/enums.js",
-			"types": "./dist/enums.d.ts"
-		},
-		"./envelope": {
-			"import": "./dist/envelope.js",
-			"types": "./dist/envelope.d.ts"
-		},
-		"./namespaces": {
-			"import": "./dist/namespaces.js",
-			"types": "./dist/namespaces.d.ts"
-		},
-		"./pubkey": {
-			"import": "./dist/pubkey.js",
-			"types": "./dist/pubkey.d.ts"
-		},
-		"./snode-retrieve": {
-			"import": "./dist/snode-retrieve.js",
-			"types": "./dist/snode-retrieve.d.ts"
-		},
-		"./snode-signature-result": {
-			"import": "./dist/snode-signature-result.js",
-			"types": "./dist/snode-signature-result.d.ts"
-		},
-		"./snode": {
-			"import": "./dist/snode.js",
-			"types": "./dist/snode.d.ts"
-		},
-		"./swarm": {
-			"import": "./dist/swarm.js",
-			"types": "./dist/swarm.d.ts"
-		}
-	},
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"files": [
@@ -85,11 +23,14 @@
 		"LICENSE"
 	],
 	"scripts": {
-		"build": "rm -rf dist && tsc --project tsconfig.build.json && tsc-alias -p tsconfig.build.json --resolve-full-paths && cp src/signal-bindings/compiled.js dist/signal-bindings/compiled.js && cp src/signal-bindings/compiled.d.ts dist/signal-bindings/compiled.d.ts",
+		"build": "rm -rf dist && tsc --project tsconfig.build.json && tsc -p tsconfig.build.json && cp src/signal-bindings/compiled.js dist/signal-bindings/compiled.js && cp src/signal-bindings/compiled.d.ts dist/signal-bindings/compiled.d.ts",
 		"protobuf": "pbjs --target static-module --wrap es6 --out src/signal-bindings/compiled.js src/signal-bindings/signalservice.proto && pbts --out src/signal-bindings/compiled.d.ts src/signal-bindings/compiled.js --force-long"
 	},
 	"dependencies": {
+		"@session.js/consts": "^1.0.4",
+		"@session.js/errors": "^1.0.11",
 		"lodash": "^4.17.21",
+		"long": "^5.3.2",
 		"protobufjs": "^7.3.2"
 	},
 	"devDependencies": {
@@ -99,7 +40,6 @@
 		"eslint-config-prettier": "^10.1.8",
 		"prettier": "^3.8.0",
 		"protobufjs-cli": "^1.1.2",
-		"tsc-alias": "^1.8.10",
 		"typescript-eslint": "^8.53.1"
 	},
 	"peerDependencies": {