@4players/odin-common/api/commands.d.ts

Commonly used type definitions and utility functions across ODIN web projects

import { type infer as ZodInfer, type ZodType } from 'zod';
import type { RpcSchema } from './serialization.ts';
import type { PeerId, PeerPosition } from './schema/peer.ts';
import type { MediaId, MediaProperties } from './schema/media.ts';
import type { RoomId } from './schema/room.ts';
import type { WebRtcUpdate } from './schema/webrtc.ts';
export type CommandSchema = {
    request: RpcSchema;
    response: RpcSchema;
};
export type Commands = Record<string, CommandSchema>;
export type CommandRequest<C extends Commands, K extends keyof C> = ZodInfer<C[K]['request']>;
export type CommandResponse<C extends Commands, K extends keyof C> = ZodInfer<C[K]['response']>;
export type ParsedCommand<C extends Commands, K extends keyof C = keyof C> = {
    [Name in K]: {
        name: Name;
        request: ZodInfer<C[Name]['request']>;
    };
}[K];
export declare function parseCommand<C extends Commands, K extends keyof C>(name: K, request: unknown, schema: C): ParsedCommand<C, K> | undefined;
export declare function parseRequest<C extends Commands, K extends keyof C>(name: K, request: unknown, schema: C): CommandRequest<C, K>;
export declare function parseResponse<C extends Commands, K extends keyof C>(name: K, response: unknown, schema: C): CommandResponse<C, K> | undefined;
export type MainCommands = {
    Hello: {
        request: ZodType<{
            stream: 'main';
        }>;
        response: ZodType<null>;
    };
    JoinRoom: {
        request: ZodType<{
            token: string;
            room_id: RoomId;
            user_data: Uint8Array;
            position: PeerPosition;
        }>;
        response: ZodType<{
            peer_id: PeerId;
            stream_id?: number;
            token?: string;
        }>;
    };
    WebRtcUpdate: {
        request: ZodType<WebRtcUpdate>;
        response: ZodType<null>;
    };
    RequestReconnectToken: {
        request: ZodType<{
            peer_id?: PeerId;
        }>;
        response: ZodType<string>;
    };
    Ping: {
        request: ZodType<Record<PropertyKey, never>>;
        response: ZodType<null>;
    };
};
export declare const MainCommandsRpc: MainCommands;
export type RoomCommands = {
    Hello: {
        request: ZodType<{
            stream: 'room';
            token: string;
            room_id: string;
            user_data: Uint8Array;
            position: PeerPosition;
        }>;
        response: ZodType<null>;
    };
    UpdatePeer: {
        request: ZodType<{
            user_data: Uint8Array;
        }>;
        response: ZodType<null>;
    };
    StartMedia: {
        request: ZodType<{
            media_id: MediaId;
            properties: MediaProperties;
        }>;
        response: ZodType<null>;
    };
    StopMedia: {
        request: ZodType<{
            media_id: MediaId;
        }>;
        response: ZodType<null>;
    };
    PauseMedia: {
        request: ZodType<{
            media_id: MediaId;
        }>;
        response: ZodType<null>;
    };
    ResumeMedia: {
        request: ZodType<{
            media_id: MediaId;
        }>;
        response: ZodType<null>;
    };
    SetPeerPosition: {
        request: ZodType<{
            position: PeerPosition;
        }>;
        response: ZodType<null>;
    };
    SendMessage: {
        request: ZodType<{
            target_peer_ids?: PeerId[];
            message: Uint8Array;
        }>;
        response: ZodType<null>;
    };
};
export declare const RoomCommandsRpc: RoomCommands;