open-collaboration-protocol/lib/messaging/messages.d.ts

Open Collaboration Protocol implementation, part of the Open Collaboration Tools project

/**
 * A collaboration message
 */
export interface Message {
    /**
     * Protocol version
     */
    version: string;
    kind: string;
    metadata: MessageMetadata;
}
export interface MessageMetadata {
    encryption: MessageEncryption;
    compression: MessageCompression;
}
export declare namespace MessageMetadata {
    function is(item: unknown): item is MessageMetadata;
}
export declare const DEFAULT_METADATA: MessageMetadata;
export interface MessageEncryption {
    keys: MessageContentKey[];
}
export declare namespace MessageEncryption {
    function is(item: unknown): item is MessageEncryption;
}
export interface MessageCompression {
    algorithm: CompressionAlgorithm;
}
export declare namespace MessageCompression {
    function is(item: unknown): item is MessageCompression;
}
export interface MessageContentKey {
    target: MessageTarget;
    key: string;
    iv: string;
}
export declare namespace MessageContentKey {
    function is(item: unknown): item is MessageContentKey;
}
export type CompressionAlgorithm = 'none' | 'gzip' | (string & {});
export interface BinaryMessage extends Message {
    content: Uint8Array;
}
export type MessageTarget = string | undefined;
export type MessageOrigin = string;
export type MessageId = number | string;
export declare namespace Message {
    function is(item: unknown): item is Message;
    function isEncrypted(item: Message): item is BinaryMessage;
}
export interface AbstractErrorMessage<T> extends Message {
    kind: 'error';
    content: T;
}
export interface ErrorMessageContent {
    message: string;
}
export type UnknownErrorMessage = AbstractErrorMessage<unknown>;
export type ErrorMessage = AbstractErrorMessage<ErrorMessageContent>;
export type BinaryErrorMessage = AbstractErrorMessage<Uint8Array>;
export declare namespace ErrorMessage {
    function create(message: string): ErrorMessage;
    function isAny(message: unknown): message is UnknownErrorMessage;
    function is(message: unknown): message is ErrorMessage;
    function isBinary(message: unknown): message is BinaryErrorMessage;
}
/**
 * Request message
 */
export interface AbstractRequestMessage<T> extends Message {
    /**
     * The request id.
     */
    id: number | string;
    kind: 'request';
    /**
     * The origin peer id of the request.
     */
    origin: MessageOrigin;
    /**
     * The peer id to which the request is addressed.
     */
    target: MessageTarget;
    content: T;
}
export interface RequestMessageContent {
    /**
     * The method to be invoked.
     */
    method: string;
    /**
     * The method's params.
     */
    params?: unknown[];
}
export type UnknownRequestMessage = AbstractRequestMessage<unknown>;
export type RequestMessage = AbstractRequestMessage<RequestMessageContent>;
export type EncryptedRequestMessage = AbstractRequestMessage<Uint8Array>;
export declare namespace RequestMessage {
    function create(signature: RequestType<any, any> | string, id: number | string, origin: MessageOrigin, target: MessageTarget, params?: any[]): RequestMessage;
    function isAny(message: unknown): message is UnknownRequestMessage;
    function is(message: unknown): message is RequestMessage;
    function isEncrypted(message: unknown): message is EncryptedRequestMessage;
}
export interface AbstractResponseMessage<T> extends Message {
    /**
     * The original request id.
     */
    id: number | string;
    kind: 'response';
    content: T;
}
export interface ResponseMessageContent {
    /**
     * The response content.
     */
    response: unknown;
}
export type UnknownResponseMessage = AbstractResponseMessage<unknown>;
export type ResponseMessage = AbstractResponseMessage<ResponseMessageContent>;
export type EncryptedResponseMessage = AbstractResponseMessage<Uint8Array>;
export declare namespace ResponseMessage {
    function create(id: number | string, response: unknown): ResponseMessage;
    function isAny(message: unknown): message is UnknownResponseMessage;
    function is(message: unknown): message is ResponseMessage;
    function isEncrypted(message: unknown): message is EncryptedResponseMessage;
}
export interface AbstractResponseErrorMessage<T> extends Message {
    /**
     * The original request id.
     */
    id: number | string;
    kind: 'response-error';
    content: T;
}
export interface ResponseErrorMessageContent {
    message: string;
}
export type UnknownResponseErrorMessage = AbstractResponseErrorMessage<unknown>;
export type ResponseErrorMessage = AbstractResponseErrorMessage<ResponseErrorMessageContent>;
export type EncryptedResponseErrorMessage = AbstractResponseErrorMessage<Uint8Array>;
export declare namespace ResponseErrorMessage {
    function create(id: number | string, message: string): ResponseErrorMessage;
    function create(id: number | string, message: Uint8Array): EncryptedResponseErrorMessage;
    function isAny(message: unknown): message is UnknownResponseErrorMessage;
    function is(message: unknown): message is ResponseErrorMessage;
    function isEncrypted(message: unknown): message is EncryptedResponseErrorMessage;
}
export interface AbstractNotificationMessage<T> extends Message {
    kind: 'notification';
    /**
     * The origin peer id of the notification.
     */
    origin: MessageOrigin;
    /**
     * The peer id to which the notification is addressed.
     */
    target: MessageTarget;
    content: T;
}
export interface NotificationMessageContent {
    /**
     * The method to be invoked.
     */
    method: string;
    /**
     * The method's params.
     */
    params?: unknown[];
}
export type UnknownNotificationMessage = AbstractNotificationMessage<unknown>;
export type NotificationMessage = AbstractNotificationMessage<NotificationMessageContent>;
export type EncryptedNotificationMessage = AbstractNotificationMessage<Uint8Array>;
export declare namespace NotificationMessage {
    function create(signature: NotificationType<any> | string, origin: MessageOrigin, target: MessageTarget, params?: any[]): NotificationMessage;
    function isAny(message: unknown): message is UnknownNotificationMessage;
    function is(message: unknown): message is NotificationMessage;
    function isEncrypted(message: unknown): message is EncryptedNotificationMessage;
}
export interface AbstractBroadcastMessage<T> extends Message {
    kind: 'broadcast';
    origin: MessageOrigin;
    content: T;
}
export interface BroadcastMessageContent {
    method: string;
    params?: unknown[];
}
export type UnknownBroadcastMessage = AbstractBroadcastMessage<unknown>;
export type BroadcastMessage = AbstractBroadcastMessage<BroadcastMessageContent>;
export type EncryptedBroadcastMessage = AbstractBroadcastMessage<Uint8Array>;
export declare namespace BroadcastMessage {
    function create(signature: BroadcastType<any> | string, origin: string, params?: any[]): BroadcastMessage;
    function isAny(message: unknown): message is UnknownBroadcastMessage;
    function is(message: unknown): message is BroadcastMessage;
    function isEncrypted(message: unknown): message is EncryptedBroadcastMessage;
}
export interface MessageSignature {
    method: string;
}
export declare class AbstractMessageSignature implements MessageSignature {
    method: string;
    constructor(method: string);
}
export declare class BroadcastType<P extends unknown[] = []> extends AbstractMessageSignature {
    readonly _?: ['broadcast', P, void];
    constructor(method: string);
}
export declare class RequestType<P extends unknown[], R> extends AbstractMessageSignature {
    readonly _?: ['request', P, R];
    constructor(method: string);
}
export declare class NotificationType<P extends unknown[]> extends AbstractMessageSignature {
    readonly _?: ['notification', P, void];
    constructor(method: string);
}
//# sourceMappingURL=messages.d.ts.map