@gbraver-burst-network/anonymous-browser-sdk 1.30.0-beta.0

package/lib/webrtc/host/host-message.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendHostMessage = exports.BattleProgressedSchema = exports.BattleStartSchema = exports.RequestSelectedPlayerSchema = void 0;
+const gbraver_burst_core_1 = require("gbraver-burst-core");
+const zod_1 = require("zod");
+/** RequestSelectedPlayer zod のスキーマ */
+exports.RequestSelectedPlayerSchema = zod_1.z.object({
+    type: zod_1.z.literal("request-selected-player"),
+    flowID: zod_1.z.string(),
+});
+/** BattleStart zod のスキーマ */
+exports.BattleStartSchema = zod_1.z.object({
+    type: zod_1.z.literal("battle-start"),
+    flowID: zod_1.z.string(),
+    hostPlayer: gbraver_burst_core_1.PlayerSchema,
+    guestPlayer: gbraver_burst_core_1.PlayerSchema,
+    update: zod_1.z.array(gbraver_burst_core_1.GameStateSchema),
+});
+/** BattleProgressed zod のスキーマ */
+exports.BattleProgressedSchema = zod_1.z.object({
+    type: zod_1.z.literal("battle-progressed"),
+    flowID: zod_1.z.string(),
+    update: zod_1.z.array(gbraver_burst_core_1.GameStateSchema),
+});
+/**
+ * ホストメッセージをゲストに送信する
+ * @param dataChannel データチャンネル
+ * @param message メッセージ内容
+ */
+const sendHostMessage = (dataChannel, message) => {
+    dataChannel.send(JSON.stringify(message));
+};
+exports.sendHostMessage = sendHostMessage;

package/lib/webrtc/host/receive-send-command.d.ts

@@ -0,0 +1,8 @@
+import { SendCommand } from "../guest/guest-message";
+/**
+ * ゲストからflowIDが一致した「SendCommand」メッセージを待ち受ける
+ * @param dataChannel データチャネル
+ * @param flowID フローID
+ * @returns フローID
+ */
+export declare const receiveSendCommand: (dataChannel: RTCDataChannel, flowID: string) => Promise<SendCommand>;

package/lib/webrtc/host/receive-send-command.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.receiveSendCommand = void 0;
+const parse_1 = require("../../json/parse");
+const guest_message_1 = require("../guest/guest-message");
+/**
+ * ゲストからflowIDが一致した「SendCommand」メッセージを待ち受ける
+ * @param dataChannel データチャネル
+ * @param flowID フローID
+ * @returns フローID
+ */
+const receiveSendCommand = (dataChannel, flowID) => {
+    let handler = null;
+    return new Promise((resolve) => {
+        handler = (event) => {
+            const data = (0, parse_1.parseJSON)(event.data);
+            const parsedSendCommand = guest_message_1.SendCommandSchema.safeParse(data);
+            if (parsedSendCommand.success &&
+                parsedSendCommand.data.flowID === flowID) {
+                resolve(parsedSendCommand.data);
+                return;
+            }
+        };
+        dataChannel.addEventListener("message", handler);
+    }).finally(() => {
+        if (handler) {
+            dataChannel.removeEventListener("message", handler);
+        }
+    });
+};
+exports.receiveSendCommand = receiveSendCommand;

package/lib/webrtc/host/request-selected-player.d.ts

@@ -0,0 +1,16 @@
+import { ArmdozerId, PilotId } from "gbraver-burst-core";
+/** ホストが選択したプレイヤーの情報 */
+type HostSelectedPlayer = {
+    /** ホストが選択したアームドーザーのID */
+    armdozerId: ArmdozerId;
+    /** ホストが選択したパイロットのID */
+    pilotId: PilotId;
+};
+/**
+ * ホストに選択したプレイヤーを共有するようにリクエストする
+ * @param dataChannel データチャンネル
+ * @param flowID ゲームのフローID
+ * @returns ホストが選択したプレイヤー情報
+ */
+export declare const requestSelectedPlayer: (dataChannel: RTCDataChannel, flowID: string) => Promise<HostSelectedPlayer>;
+export {};

package/lib/webrtc/host/request-selected-player.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestSelectedPlayer = void 0;
+const parse_1 = require("../../json/parse");
+const guest_message_1 = require("../guest/guest-message");
+const host_message_1 = require("./host-message");
+/**
+ * ホストに選択したプレイヤーを共有するようにリクエストする
+ * @param dataChannel データチャンネル
+ * @param flowID ゲームのフローID
+ * @returns ホストが選択したプレイヤー情報
+ */
+const requestSelectedPlayer = (dataChannel, flowID) => {
+    let handler = null;
+    return new Promise((resolve) => {
+        handler = (event) => {
+            const data = (0, parse_1.parseJSON)(event.data);
+            const parsedSendPlayer = guest_message_1.SendPlayerSchema.safeParse(data);
+            if (parsedSendPlayer.success && parsedSendPlayer.data.flowID === flowID) {
+                const { armdozerId, pilotId } = parsedSendPlayer.data;
+                resolve({ armdozerId, pilotId });
+            }
+        };
+        dataChannel.addEventListener("message", handler);
+        (0, host_message_1.sendHostMessage)(dataChannel, {
+            type: "request-selected-player",
+            flowID,
+        });
+    }).finally(() => {
+        if (handler) {
+            dataChannel.removeEventListener("message", handler);
+        }
+    });
+};
+exports.requestSelectedPlayer = requestSelectedPlayer;

package/lib/webrtc/notify-connection-failed.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from "rxjs";
+/**
+ * コネクションがfailed状態になったことを通知するObservableを返す
+ * @param connection WebRTCコネクション
+ * @returns failed状態になったことを通知するObservable
+ */
+export declare const notifyConnectionFailed: (connection: RTCPeerConnection) => Observable<unknown>;

package/lib/webrtc/notify-connection-failed.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyConnectionFailed = void 0;
+const rxjs_1 = require("rxjs");
+/**
+ * コネクションがfailed状態になったことを通知するObservableを返す
+ * @param connection WebRTCコネクション
+ * @returns failed状態になったことを通知するObservable
+ */
+const notifyConnectionFailed = (connection) => (0, rxjs_1.merge)((0, rxjs_1.fromEvent)(connection, "connectionstatechange").pipe((0, rxjs_1.map)(() => connection.connectionState)), (0, rxjs_1.fromEvent)(connection, "iceconnectionstatechange").pipe((0, rxjs_1.map)(() => connection.iceConnectionState))).pipe((0, rxjs_1.filter)((state) => state === "failed"));
+exports.notifyConnectionFailed = notifyConnectionFailed;

package/lib/webrtc/rtc-ice-candidate-init-schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/** RTCIceCandidateInit の zod スキーマ */
+export declare const RTCIceCandidateInitSchema: z.ZodObject<{
+    candidate: z.ZodOptional<z.ZodString>;
+    sdpMLineIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    sdpMid: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    usernameFragment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;

package/lib/webrtc/rtc-ice-candidate-init-schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCIceCandidateInitSchema = void 0;
+const zod_1 = require("zod");
+/** RTCIceCandidateInit の zod スキーマ */
+exports.RTCIceCandidateInitSchema = zod_1.z.object({
+    candidate: zod_1.z.string().optional(),
+    sdpMLineIndex: zod_1.z.number().nullable().optional(),
+    sdpMid: zod_1.z.string().nullable().optional(),
+    usernameFragment: zod_1.z.string().nullable().optional(),
+});

package/lib/webrtc/rtc-session-description-init-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/** Session Descriptionのzodスキーマ */
+export declare const RTCSessionDescriptionInitSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        offer: "offer";
+        pranswer: "pranswer";
+        answer: "answer";
+        rollback: "rollback";
+    }>;
+    sdp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/lib/webrtc/rtc-session-description-init-schema.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTCSessionDescriptionInitSchema = void 0;
+const zod_1 = require("zod");
+/** Session Descriptionのzodスキーマ */
+exports.RTCSessionDescriptionInitSchema = zod_1.z.object({
+    type: zod_1.z.enum(["offer", "pranswer", "answer", "rollback"]),
+    sdp: zod_1.z.string().optional(),
+});

package/lib/webrtc/wait-until-connected.d.ts

@@ -0,0 +1,6 @@
+/**
+ * WebRTCコネクションが接続されるまで待機する
+ * @param connection WebRTCコネクション
+ * @returns 接続されたら発火するPromise
+ */
+export declare const waitUntilConnected: (connection: RTCPeerConnection) => Promise<void>;

package/lib/webrtc/wait-until-connected.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilConnected = void 0;
+/**
+ * WebRTCコネクションが接続されるまで待機する
+ * @param connection WebRTCコネクション
+ * @returns 接続されたら発火するPromise
+ */
+const waitUntilConnected = (connection) => {
+    let handler = null;
+    return new Promise((resolve) => {
+        if (connection.connectionState === "connected") {
+            resolve();
+            return;
+        }
+        handler = () => {
+            if (connection.connectionState === "connected") {
+                resolve();
+            }
+        };
+        connection.addEventListener("connectionstatechange", handler);
+    }).finally(() => {
+        if (handler) {
+            connection.removeEventListener("connectionstatechange", handler);
+        }
+    });
+};
+exports.waitUntilConnected = waitUntilConnected;

package/lib/webrtc/wait-until-data-channel-ready.d.ts

@@ -0,0 +1,6 @@
+/**
+ * データチャンネルが開通するのを待つ
+ * @param dataChannel データチャンネル
+ * @returns データチャンネルが開通したら発火するPromise
+ */
+export declare const waitUntilDataChannelOpen: (dataChannel: RTCDataChannel) => Promise<void>;

package/lib/webrtc/wait-until-data-channel-ready.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilDataChannelOpen = void 0;
+/**
+ * データチャンネルが開通するのを待つ
+ * @param dataChannel データチャンネル
+ * @returns データチャンネルが開通したら発火するPromise
+ */
+const waitUntilDataChannelOpen = (dataChannel) => {
+    let handler = null;
+    return new Promise((resolve) => {
+        if (dataChannel.readyState === "open") {
+            resolve();
+            return;
+        }
+        handler = () => {
+            if (dataChannel.readyState === "open") {
+                resolve();
+            }
+        };
+        dataChannel.addEventListener("open", handler);
+    }).finally(() => {
+        if (handler) {
+            dataChannel.removeEventListener("open", handler);
+        }
+    });
+};
+exports.waitUntilDataChannelOpen = waitUntilDataChannelOpen;

package/lib/websocket-api/connect-ws-signal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * WebSocketシグナルサーバーに接続する
+ * @param url 接続先のWebSocketシグナルサーバーのURL
+ * @param token 認証トークン
+ * @returns 接続に成功したWebSocket、接続に失敗した場合はPromiseがrejectされる
+ */
+export declare function connectWSSignal(url: string, token: string): Promise<WebSocket>;

package/lib/websocket-api/connect-ws-signal.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectWSSignal = connectWSSignal;
+/**
+ * WebSocketシグナルサーバーに接続する
+ * @param url 接続先のWebSocketシグナルサーバーのURL
+ * @param token 認証トークン
+ * @returns 接続に成功したWebSocket、接続に失敗した場合はPromiseがrejectされる
+ */
+function connectWSSignal(url, token) {
+    let handler = null;
+    let errorHandler = null;
+    const websocket = new WebSocket(`${url}?token=${token}`);
+    return new Promise((resolve, reject) => {
+        handler = () => {
+            resolve(websocket);
+        };
+        errorHandler = reject;
+        websocket.addEventListener("open", handler);
+        websocket.addEventListener("error", errorHandler);
+    }).finally(() => {
+        if (handler) {
+            websocket.removeEventListener("open", handler);
+        }
+        if (errorHandler) {
+            websocket.removeEventListener("error", errorHandler);
+        }
+    });
+}

package/lib/websocket-api/create-room.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ルームを生成する
+ * @param websocket WebSocketコネクション
+ * @returns 成功したらルームID、失敗したらnull
+ */
+export declare const createRoom: (websocket: WebSocket) => Promise<string | null>;

package/lib/websocket-api/create-room.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoom = void 0;
+const parse_1 = require("../json/parse");
+const room_creation_result_1 = require("./response/room-creation-result");
+const send_to_ws_signal_1 = require("./send-to-ws-signal");
+/**
+ * ルームを生成する
+ * @param websocket WebSocketコネクション
+ * @returns 成功したらルームID、失敗したらnull
+ */
+const createRoom = (websocket) => {
+    let handler = null;
+    return new Promise((resolve) => {
+        handler = (event) => {
+            const parsedData = (0, parse_1.parseJSON)(event.data);
+            const parsedRoomCreationSuccessSchema = room_creation_result_1.RoomCreationSuccessSchema.safeParse(parsedData);
+            if (parsedRoomCreationSuccessSchema.success) {
+                const roomCreationSuccess = parsedRoomCreationSuccessSchema.data;
+                resolve(roomCreationSuccess.roomID);
+                return;
+            }
+            const parsedRoomCreationFailure = room_creation_result_1.RoomCreationFailureSchema.safeParse(parsedData);
+            if (parsedRoomCreationFailure.success) {
+                resolve(null);
+                return;
+            }
+        };
+        websocket.addEventListener("message", handler);
+        (0, send_to_ws_signal_1.sendToWSSignal)(websocket, { action: "create-room" });
+    }).finally(() => {
+        if (handler) {
+            websocket.removeEventListener("message", handler);
+        }
+    });
+};
+exports.createRoom = createRoom;

package/lib/websocket-api/delete-signaling-channel.d.ts

@@ -0,0 +1,11 @@
+/**
+ * シグナリングチャネルを削除する
+ * @param options オプション
+ * @param options.websocket WebSocketコネクション
+ * @param options.signalingID 削除するシグナリングチャネルのID
+ * @return シグナリングチャネルの削除に成功したらtrue、失敗したらfalse
+ */
+export declare const deleteSignalingChannel: (options: {
+    websocket: WebSocket;
+    signalingID: string;
+}) => Promise<boolean>;

package/lib/websocket-api/delete-signaling-channel.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSignalingChannel = void 0;
+const parse_1 = require("../json/parse");
+const delete_signaling_channel_accepted_1 = require("./response/delete-signaling-channel-accepted");
+const delete_signaling_channel_rejected_1 = require("./response/delete-signaling-channel-rejected");
+const send_to_ws_signal_1 = require("./send-to-ws-signal");
+/**
+ * シグナリングチャネルを削除する
+ * @param options オプション
+ * @param options.websocket WebSocketコネクション
+ * @param options.signalingID 削除するシグナリングチャネルのID
+ * @return シグナリングチャネルの削除に成功したらtrue、失敗したらfalse
+ */
+const deleteSignalingChannel = (options) => {
+    const { websocket, signalingID } = options;
+    let handler = null;
+    return new Promise((resolve) => {
+        handler = (event) => {
+            const parsedData = (0, parse_1.parseJSON)(event.data);
+            const deleteSignalingChannelAccepted = delete_signaling_channel_accepted_1.DeleteSignalingChannelAcceptedSchema.safeParse(parsedData);
+            if (deleteSignalingChannelAccepted.success) {
+                resolve(true);
+                return;
+            }
+            const deleteSignalingChannelRejected = delete_signaling_channel_rejected_1.DeleteSignalingChannelRejectedSchema.safeParse(parsedData);
+            if (deleteSignalingChannelRejected.success) {
+                resolve(false);
+                return;
+            }
+        };
+        websocket.addEventListener("message", handler);
+        (0, send_to_ws_signal_1.sendToWSSignal)(websocket, {
+            action: "delete-signaling-channel",
+            signalingID,
+        });
+    }).finally(() => {
+        if (handler) {
+            websocket.removeEventListener("message", handler);
+        }
+    });
+};
+exports.deleteSignalingChannel = deleteSignalingChannel;

package/lib/websocket-api/join-room.d.ts

@@ -0,0 +1,12 @@
+import { JoinRoomAccepted } from "./response/join-room-accepted";
+/**
+ * ルームに参加する
+ * @param options オプション
+ * @param options.websocket WebSocketコネクション
+ * @param options.roomID 参加するルームのID
+ * @return ルームへの参加に成功したらJoinRoomAccepted、失敗したらnull
+ */
+export declare const joinRoom: (options: {
+    websocket: WebSocket;
+    roomID: string;
+}) => Promise<JoinRoomAccepted | null>;

package/lib/websocket-api/join-room.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinRoom = void 0;
+const parse_1 = require("../json/parse");
+const join_room_accepted_1 = require("./response/join-room-accepted");
+const join_room_rejected_1 = require("./response/join-room-rejected");
+const send_to_ws_signal_1 = require("./send-to-ws-signal");
+/**
+ * ルームに参加する
+ * @param options オプション
+ * @param options.websocket WebSocketコネクション
+ * @param options.roomID 参加するルームのID
+ * @return ルームへの参加に成功したらJoinRoomAccepted、失敗したらnull
+ */
+const joinRoom = (options) => {
+    const { websocket, roomID } = options;
+    let handler = null;
+    return new Promise((resolve) => {
+        handler = (event) => {
+            const parsedData = (0, parse_1.parseJSON)(event.data);
+            const parsedJoinRoomAccepted = join_room_accepted_1.JoinRoomAcceptedSchema.safeParse(parsedData);
+            if (parsedJoinRoomAccepted.success) {
+                resolve(parsedJoinRoomAccepted.data);
+                return;
+            }
+            const parsedJoinRoomRejected = join_room_rejected_1.JoinRoomRejectedSchema.safeParse(parsedData);
+            if (parsedJoinRoomRejected.success) {
+                resolve(null);
+                return;
+            }
+        };
+        websocket.addEventListener("message", handler);
+        (0, send_to_ws_signal_1.sendToWSSignal)(websocket, { action: "join-room", roomID });
+    }).finally(() => {
+        if (handler) {
+            websocket.removeEventListener("message", handler);
+        }
+    });
+};
+exports.joinRoom = joinRoom;

package/lib/websocket-api/notify-ice-candidate-recieved.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from "rxjs";
+/**
+ * ICE candidate を受信したことを通知する
+ * @param websocket WebSocketコネクション
+ * @returns 通知ストリーム
+ */
+export declare const notifyIceCandidateReceived: (websocket: WebSocket) => Observable<RTCIceCandidateInit>;

package/lib/websocket-api/notify-ice-candidate-recieved.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyIceCandidateReceived = void 0;
+const rxjs_1 = require("rxjs");
+const parse_1 = require("../json/parse");
+const receive_ice_candidate_1 = require("./response/receive-ice-candidate");
+/**
+ * ICE candidate を受信したことを通知する
+ * @param websocket WebSocketコネクション
+ * @returns 通知ストリーム
+ */
+const notifyIceCandidateReceived = (websocket) => (0, rxjs_1.fromEvent)(websocket, "message").pipe((0, rxjs_1.map)((event) => (0, parse_1.parseJSON)(event.data)), (0, rxjs_1.map)((data) => receive_ice_candidate_1.ReceiveICECandidateSchema.safeParse(data)), (0, rxjs_1.filter)((data) => data.success), (0, rxjs_1.map)((data) => data.data.iceCandidate));
+exports.notifyIceCandidateReceived = notifyIceCandidateReceived;

package/lib/websocket-api/request/create-room.d.ts

@@ -0,0 +1,4 @@
+/** ホストがルームを作成する */
+export type CreateRoom = {
+    action: "create-room";
+};

package/lib/websocket-api/request/create-room.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/websocket-api/request/delete-signaling-channel.d.ts

@@ -0,0 +1,6 @@
+/** シグナリングチャネルを削除する */
+export type DeleteSignalingChannel = {
+    action: "delete-signaling-channel";
+    /** 削除対象となるシグナリングのID */
+    signalingID: string;
+};

package/lib/websocket-api/request/delete-signaling-channel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/websocket-api/request/index.d.ts

@@ -0,0 +1,7 @@
+import { CreateRoom } from "./create-room";
+import { DeleteSignalingChannel } from "./delete-signaling-channel";
+import { JoinRoom } from "./join-room";
+import { SendICECandidate } from "./send-ice-candidate";
+import { SendSDP } from "./send-sdp";
+/** WebSocketシグナルサーバーへのリクエスト */
+export type WSSignalRequest = CreateRoom | JoinRoom | SendSDP | SendICECandidate | DeleteSignalingChannel;

package/lib/websocket-api/request/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/websocket-api/request/join-room.d.ts

@@ -0,0 +1,6 @@
+/** ゲストが入室する */
+export type JoinRoom = {
+    action: "join-room";
+    /** ルームID */
+    roomID: string;
+};

package/lib/websocket-api/request/join-room.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/websocket-api/request/send-ice-candidate.d.ts

@@ -0,0 +1,8 @@
+/** ICE candidateを送信する */
+export type SendICECandidate = {
+    action: "send-ice-candidate";
+    /** シグナリングID */
+    signalingID: string;
+    /** ICE candidate */
+    iceCandidate: RTCIceCandidateInit;
+};

package/lib/websocket-api/request/send-ice-candidate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/websocket-api/request/send-sdp.d.ts

@@ -0,0 +1,8 @@
+/** SDPを送信する */
+export type SendSDP = {
+    action: "send-sdp";
+    /** シグナリングID */
+    signalingID: string;
+    /** SDP */
+    sdp: RTCSessionDescriptionInit;
+};

package/lib/websocket-api/request/send-sdp.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/websocket-api/response/delete-signaling-channel-accepted.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+/** シグナリングチャネルの削除に成功した */
+export type DeleteSignalingChannelAccepted = {
+    type: "delete-signaling-channel-accepted";
+};
+/** DeleteSignalingChannelAccepted zodスキーマ */
+export declare const DeleteSignalingChannelAcceptedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"delete-signaling-channel-accepted">;
+}, z.core.$strip>;

package/lib/websocket-api/response/delete-signaling-channel-accepted.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteSignalingChannelAcceptedSchema = void 0;
+const zod_1 = require("zod");
+/** DeleteSignalingChannelAccepted zodスキーマ */
+exports.DeleteSignalingChannelAcceptedSchema = zod_1.z.object({
+    type: zod_1.z.literal("delete-signaling-channel-accepted"),
+});

package/lib/websocket-api/response/delete-signaling-channel-rejected.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+/** シグナリングチャネルの削除が拒否された */
+export type DeleteSignalingChannelRejected = {
+    type: "delete-signaling-channel-rejected";
+};
+/** DeleteSignalingChannelRejected zodスキーマ  */
+export declare const DeleteSignalingChannelRejectedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"delete-signaling-channel-rejected">;
+}, z.core.$strip>;

package/lib/websocket-api/response/delete-signaling-channel-rejected.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteSignalingChannelRejectedSchema = void 0;
+const zod_1 = require("zod");
+/** DeleteSignalingChannelRejected zodスキーマ  */
+exports.DeleteSignalingChannelRejectedSchema = zod_1.z.object({
+    type: zod_1.z.literal("delete-signaling-channel-rejected"),
+});

package/lib/websocket-api/response/join-room-accepted.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+/** ルーム参加承認 */
+export type JoinRoomAccepted = {
+    type: "join-room-accepted";
+    /** シグナリングID */
+    signalingID: string;
+};
+/** JoinRoomAccepted zod スキーマ */
+export declare const JoinRoomAcceptedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"join-room-accepted">;
+    signalingID: z.ZodString;
+}, z.core.$strip>;

package/lib/websocket-api/response/join-room-accepted.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinRoomAcceptedSchema = void 0;
+const zod_1 = require("zod");
+/** JoinRoomAccepted zod スキーマ */
+exports.JoinRoomAcceptedSchema = zod_1.z.object({
+    type: zod_1.z.literal("join-room-accepted"),
+    signalingID: zod_1.z.string(),
+});

package/lib/websocket-api/response/join-room-rejected.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+/** 入室が拒否された */
+export type JoinRoomRejected = {
+    type: "join-room-rejected";
+};
+/** JoinRoomRejected zod スキーマ */
+export declare const JoinRoomRejectedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"join-room-rejected">;
+}, z.core.$strip>;