@encarnage7/local-meet 0.0.0-stage → 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,223 @@
+/**
+ * TypeScript Declarations for Local Meet SDK
+ */
+
+export type EngineMode = "cf-calls" | "p2p" | "livekit";
+
+export type RoomEventType =
+  | "participantConnected"
+  | "participantDisconnected"
+  | "participantMetadataChanged"
+  | "participantPermissionsChanged"
+  | "dataReceived"
+  | "trackSubscribed"
+  | "trackUnsubscribed"
+  | "trackUnpublished"
+  | "localTrackPublished"
+  | "localTrackUnpublished"
+  | "trackMuted"
+  | "trackUnmuted"
+  | "activeSpeakersChanged"
+  | "disconnected"
+  | "error";
+
+export const RoomEvents: {
+  readonly ParticipantConnected: "participantConnected";
+  readonly ParticipantDisconnected: "participantDisconnected";
+  readonly ParticipantMetadataChanged: "participantMetadataChanged";
+  readonly ParticipantPermissionsChanged: "participantPermissionsChanged";
+  readonly DataReceived: "dataReceived";
+  readonly TrackSubscribed: "trackSubscribed";
+  readonly TrackUnsubscribed: "trackUnsubscribed";
+  readonly TrackUnpublished: "trackUnpublished";
+  readonly LocalTrackPublished: "localTrackPublished";
+  readonly LocalTrackUnpublished: "localTrackUnpublished";
+  readonly TrackMuted: "trackMuted";
+  readonly TrackUnmuted: "trackUnmuted";
+  readonly ActiveSpeakersChanged: "activeSpeakersChanged";
+  readonly Disconnected: "disconnected";
+  readonly Error: "error";
+};
+
+export const TrackSources: {
+  readonly Camera: "camera";
+  readonly Microphone: "microphone";
+  readonly ScreenShare: "screen_share";
+  readonly ScreenShareAudio: "screen_share_audio";
+};
+
+export const TrackKinds: {
+  readonly Audio: "audio";
+  readonly Video: "video";
+};
+
+export const EngineModes: {
+  readonly CloudflareCalls: "cf-calls";
+  readonly P2PMesh: "p2p";
+  readonly LiveKit: "livekit";
+};
+
+export interface IceServerConfig {
+  urls: string | string[];
+  username?: string;
+  credential?: string;
+}
+
+export interface LocalMeetRoomOptions {
+  serverUrl?: string;
+  roomHash: string;
+  title?: string;
+  identity?: string;
+  displayName?: string;
+  isHost?: boolean;
+  hostSecret?: string;
+  engine?: EngineMode;
+  cfCallsReady?: boolean;
+  startInWaitingRoom?: boolean;
+  iceServers?: IceServerConfig[];
+  debug?: boolean;
+}
+
+export interface CreateRoomOptions {
+  serverUrl?: string;
+  hostName?: string;
+  title?: string;
+  engine?: EngineMode;
+  accessKey?: string;
+  customHash?: string;
+  hostSecret?: string;
+  debug?: boolean;
+}
+
+export interface JoinRoomOptions {
+  serverUrl?: string;
+  roomHash: string;
+  guestName?: string;
+  debug?: boolean;
+}
+
+export class HybridTrack {
+  mediaStreamTrack: MediaStreamTrack;
+  kind: "audio" | "video";
+  source: string;
+  mediaStream: MediaStream | null;
+  primaryElement: HTMLMediaElement | null;
+  attachedElements: Set<HTMLMediaElement>;
+
+  constructor(mediaStreamTrack: MediaStreamTrack, kind: "audio" | "video", source: string);
+  attach(existingElement?: HTMLMediaElement | null): HTMLMediaElement;
+  detach(): HTMLMediaElement[];
+  stop(): void;
+}
+
+export class HybridPublication {
+  trackSid: string;
+  source: string;
+  track: HybridTrack | null;
+  isMuted: boolean;
+
+  constructor(params: {
+    trackSid: string;
+    source: string;
+    track?: HybridTrack | null;
+    isMuted?: boolean;
+  });
+}
+
+export class HybridParticipant {
+  identity: string;
+  name: string;
+  metadata: string;
+  permissions: {
+    canPublish: boolean;
+    canSubscribe: boolean;
+    canPublishData: boolean;
+  };
+  isLocal: boolean;
+  trackPublications: Map<string, HybridPublication>;
+  videoTrackPublications: Map<string, HybridPublication>;
+  peerId: string;
+  cfSessionId: string;
+  cfPublishedTracks: string[];
+
+  constructor(params: {
+    identity: string;
+    name: string;
+    metadata?: string;
+    permissions?: Partial<HybridParticipant["permissions"]>;
+    isLocal?: boolean;
+    room?: any;
+  });
+
+  getTrackPublication(source: string): HybridPublication | null;
+  setPublication(source: string, publication: HybridPublication | null): void;
+  enableCameraAndMicrophone(): Promise<void>;
+  setMicrophoneEnabled(enabled: boolean): Promise<void>;
+  setCameraEnabled(enabled: boolean): Promise<void>;
+  setScreenShareEnabled(enabled: boolean): Promise<HybridPublication | null>;
+  publishData(payload: Uint8Array | string | object, options?: { reliable?: boolean }): Promise<void>;
+}
+
+export class LocalMeetRoom {
+  serverUrl: string;
+  roomHash: string;
+  roomTitle: string;
+  isHost: boolean;
+  hostSecret: string;
+  engine: EngineMode;
+  cfCallsReady: boolean;
+  debug: boolean;
+  localParticipant: HybridParticipant;
+  remoteParticipants: Map<string, HybridParticipant>;
+  iceServers: IceServerConfig[];
+
+  constructor(options: LocalMeetRoomOptions);
+
+  on(event: RoomEventType | string, callback: (...args: any[]) => void): this;
+  off(event: RoomEventType | string, callback: (...args: any[]) => void): this;
+  emit(event: RoomEventType | string, ...args: any[]): void;
+
+  connect(): Promise<this>;
+  enableCameraAndMicrophone(): Promise<void>;
+  setMicrophoneEnabled(enabled: boolean): Promise<void>;
+  setCameraEnabled(enabled: boolean): Promise<void>;
+  setScreenShareEnabled(enabled: boolean, stopTracks?: boolean): Promise<HybridPublication | null>;
+  startScreenShare(): Promise<HybridPublication | null>;
+  stopScreenShare(): Promise<HybridPublication | null>;
+  sendData(payload: Uint8Array | string | object, options?: { reliable?: boolean }): Promise<void>;
+
+  admitGuest(identity: string): Promise<void>;
+  rejectGuest(identity: string): Promise<void>;
+  muteParticipant(identity: string, trackSid?: string): Promise<void>;
+  kickParticipant(identity: string): Promise<void>;
+  endRoom(): Promise<void>;
+  disconnect(): void;
+}
+
+export const LocalMeet: {
+  RoomEvents: typeof RoomEvents;
+  TrackSources: typeof TrackSources;
+  TrackKinds: typeof TrackKinds;
+  EngineModes: typeof EngineModes;
+  LocalMeetRoom: typeof LocalMeetRoom;
+  HybridTrack: typeof HybridTrack;
+  HybridPublication: typeof HybridPublication;
+  HybridParticipant: typeof HybridParticipant;
+
+  createRoom(options?: CreateRoomOptions): Promise<LocalMeetRoom>;
+  join(options?: JoinRoomOptions): Promise<LocalMeetRoom>;
+};
+
+export function encryptDataPacket(
+  roomHash: string,
+  plaintext: string,
+  extraSecret?: string
+): Promise<{ e2ee: string; iv: string; ct: string }>;
+
+export function decryptDataPacket(
+  roomHash: string,
+  packet: { e2ee: string; iv: string; ct: string },
+  extraSecret?: string
+): Promise<string | null>;
+
+export default LocalMeet;