feat(private-room): connect moments feed

src/data/dto/private-room/__tests__/private_room.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  PrivateRoomMomentsResponse,
+  PrivateRoomUnlockResponse,
+} from "@/data/dto/private-room";
+import { ApiPath } from "@/data/services/api";
+
+const lockedMoment = {
+  momentId: "schedule:91",
+  source: "elio_schedules",
+  sourceId: "91",
+  characterId: "elio",
+  author: {
+    id: "elio",
+    name: "Elio Silvestri",
+    avatarUrl: null,
+  },
+  createdAt: "2026-07-01T08:11:35+00:00",
+  publishedAt: "2026-07-01T08:11:35+00:00",
+  timeText: "7 days ago",
+  title: "Paris morning",
+  content: null,
+  text: null,
+  textPreview: "Unlock to view private room photos",
+  mediaCount: 1,
+  images: [
+    {
+      url: null,
+      type: "image",
+      locked: true,
+      index: 0,
+    },
+  ],
+  locked: true,
+  unlocked: false,
+  unlockCost: 40,
+  unlockCostPerImage: 40,
+  requiredCredits: 40,
+  currency: "credits",
+  lockDetail: {
+    locked: true,
+    showContent: false,
+    showUpgrade: true,
+    reason: "private_room_moment",
+    hint: "40 credits · Unlock photo",
+    actionLabel: "Unlock",
+    type: "private_room_moment",
+    requiredCredits: 40,
+    currentCredits: 100,
+    shortfallCredits: 0,
+    mediaCount: 1,
+    unlockCostPerImage: 40,
+  },
+};
+
+describe("PrivateRoom DTOs", () => {
+  it("parses locked moments without image URLs", () => {
+    const response = PrivateRoomMomentsResponse.from({
+      profile: {
+        characterId: "elio",
+        displayName: "Elio Silvestri",
+        authorName: "Elio Silvestri",
+        avatarUrl: null,
+        coverUrl: null,
+        title: "Elio Private room",
+        subtitle: "Join me, unlock my private room",
+      },
+      items: [lockedMoment],
+      nextCursor: null,
+      hasMore: false,
+      creditBalance: 100,
+      unlockCostDefault: 40,
+      unlockCostPerImage: 40,
+      currency: "credits",
+      source: "elio_schedules",
+    });
+
+    expect(response.items[0]?.locked).toBe(true);
+    expect(response.items[0]?.images[0]?.url).toBeNull();
+    expect(response.items[0]?.unlockCost).toBe(40);
+    expect(response.profile.displayName).toBe("Elio Silvestri");
+  });
+
+  it("parses unlock success with real image URLs", () => {
+    const response = PrivateRoomUnlockResponse.from({
+      ...lockedMoment,
+      locked: false,
+      unlocked: true,
+      content: "A quiet morning in Paris.",
+      text: "A quiet morning in Paris.",
+      images: [
+        {
+          url: "https://lehwkihwnlqkavhcspel.supabase.co/storage/v1/object/public/elio-schedules/schedules/91/photo.jpg",
+          type: "image",
+          locked: false,
+          index: 0,
+        },
+      ],
+      reason: "ok",
+      creditsCharged: 40,
+      creditBalance: 60,
+      previousCreditBalance: 100,
+      persisted: true,
+    });
+
+    expect(response.unlocked).toBe(true);
+    expect(response.reason).toBe("ok");
+    expect(response.images[0]?.url).toContain("https://");
+    expect(response.creditBalance).toBe(60);
+  });
+
+  it("parses insufficient credits as business data", () => {
+    const response = PrivateRoomUnlockResponse.from({
+      ...lockedMoment,
+      reason: "insufficient_credits",
+      currentCredits: 10,
+      shortfallCredits: 30,
+      creditBalance: 10,
+    });
+
+    expect(response.unlocked).toBe(false);
+    expect(response.locked).toBe(true);
+    expect(response.reason).toBe("insufficient_credits");
+    expect(response.images[0]?.url).toBeNull();
+  });
+
+  it("encodes moment id in the unlock path", () => {
+    expect(ApiPath.privateRoomMomentUnlock("schedule:91")).toBe(
+      "/api/private-room/moments/schedule%3A91/unlock",
+    );
+  });
+});

src/data/dto/private-room/index.ts

@@ -0,0 +1,3 @@
+export * from "./private_room_moment";
+export * from "./request";
+export * from "./response";

src/data/dto/private-room/private_room_moment.ts

@@ -0,0 +1,51 @@
+import {
+  PrivateRoomMomentSchema,
+  type PrivateRoomMomentData,
+  type PrivateRoomMomentInput,
+} from "@/data/schemas/private-room";
+
+export class PrivateRoomMoment {
+  declare readonly momentId: string;
+  declare readonly source: string;
+  declare readonly sourceId: string;
+  declare readonly characterId: string;
+  declare readonly author: PrivateRoomMomentData["author"];
+  declare readonly createdAt: string | null;
+  declare readonly publishedAt: string | null;
+  declare readonly timeText: string;
+  declare readonly title: string;
+  declare readonly content: string | null;
+  declare readonly text: string | null;
+  declare readonly textPreview: string;
+  declare readonly mediaCount: number;
+  declare readonly images: PrivateRoomMomentData["images"];
+  declare readonly locked: boolean;
+  declare readonly unlocked: boolean;
+  declare readonly unlockCost: number;
+  declare readonly unlockCostPerImage: number;
+  declare readonly requiredCredits: number;
+  declare readonly currency: string;
+  declare readonly lockDetail: PrivateRoomMomentData["lockDetail"];
+
+  protected constructor(input: PrivateRoomMomentInput, freeze = true) {
+    const data = PrivateRoomMomentSchema.parse(input);
+    Object.assign(this, data);
+    if (freeze) Object.freeze(this);
+  }
+
+  static from(input: PrivateRoomMomentInput): PrivateRoomMoment {
+    return new PrivateRoomMoment(input);
+  }
+
+  static fromJson(json: unknown): PrivateRoomMoment {
+    return PrivateRoomMoment.from(json as PrivateRoomMomentInput);
+  }
+
+  toJson(): PrivateRoomMomentData {
+    return PrivateRoomMomentSchema.parse(this);
+  }
+}
+
+export type PrivateRoomProfile = import("@/data/schemas/private-room").PrivateRoomProfileData;
+export type PrivateRoomImage = import("@/data/schemas/private-room").PrivateRoomImageData;
+export type PrivateRoomLockDetail = import("@/data/schemas/private-room").PrivateRoomLockDetailData;

src/data/dto/private-room/request/index.ts

@@ -0,0 +1 @@
+export * from "./unlock_private_room_moment_request";

src/data/dto/private-room/request/unlock_private_room_moment_request.ts

@@ -0,0 +1,31 @@
+import {
+  UnlockPrivateRoomMomentRequestSchema,
+  type UnlockPrivateRoomMomentRequestData,
+  type UnlockPrivateRoomMomentRequestInput,
+} from "@/data/schemas/private-room";
+
+export class UnlockPrivateRoomMomentRequest {
+  declare readonly expectedCost: number;
+
+  private constructor(input: UnlockPrivateRoomMomentRequestInput) {
+    const data = UnlockPrivateRoomMomentRequestSchema.parse(input);
+    Object.assign(this, data);
+    Object.freeze(this);
+  }
+
+  static from(
+    input: UnlockPrivateRoomMomentRequestInput,
+  ): UnlockPrivateRoomMomentRequest {
+    return new UnlockPrivateRoomMomentRequest(input);
+  }
+
+  static fromJson(json: unknown): UnlockPrivateRoomMomentRequest {
+    return UnlockPrivateRoomMomentRequest.from(
+      json as UnlockPrivateRoomMomentRequestInput,
+    );
+  }
+
+  toJson(): UnlockPrivateRoomMomentRequestData {
+    return UnlockPrivateRoomMomentRequestSchema.parse(this);
+  }
+}

src/data/dto/private-room/response/index.ts

@@ -0,0 +1,2 @@
+export * from "./private_room_moments_response";
+export * from "./private_room_unlock_response";

src/data/dto/private-room/response/private_room_moments_response.ts

@@ -0,0 +1,54 @@
+import {
+  PrivateRoomMomentsResponseSchema,
+  type PrivateRoomMomentsResponseData,
+  type PrivateRoomMomentsResponseInput,
+} from "@/data/schemas/private-room";
+
+import { PrivateRoomMoment } from "../private_room_moment";
+
+export class PrivateRoomMomentsResponse {
+  declare readonly profile: PrivateRoomMomentsResponseData["profile"];
+  declare readonly items: PrivateRoomMoment[];
+  declare readonly nextCursor: string | null;
+  declare readonly hasMore: boolean;
+  declare readonly creditBalance: number;
+  declare readonly unlockCostDefault: number;
+  declare readonly unlockCostPerImage: number;
+  declare readonly currency: string;
+  declare readonly source: string;
+
+  private constructor(input: PrivateRoomMomentsResponseInput) {
+    const data = PrivateRoomMomentsResponseSchema.parse(input);
+    Object.assign(this, {
+      ...data,
+      items: data.items.map((item) => PrivateRoomMoment.from(item)),
+    });
+    Object.freeze(this);
+  }
+
+  static from(
+    input: PrivateRoomMomentsResponseInput,
+  ): PrivateRoomMomentsResponse {
+    return new PrivateRoomMomentsResponse(input);
+  }
+
+  static fromJson(json: unknown): PrivateRoomMomentsResponse {
+    return PrivateRoomMomentsResponse.from(
+      json as PrivateRoomMomentsResponseInput,
+    );
+  }
+
+  toJson(): PrivateRoomMomentsResponseData {
+    return {
+      profile: this.profile,
+      items: this.items.map((item) => item.toJson()),
+      nextCursor: this.nextCursor,
+      hasMore: this.hasMore,
+      creditBalance: this.creditBalance,
+      unlockCostDefault: this.unlockCostDefault,
+      unlockCostPerImage: this.unlockCostPerImage,
+      currency: this.currency,
+      source: this.source,
+    };
+  }
+}

src/data/dto/private-room/response/private_room_unlock_response.ts

@@ -0,0 +1,41 @@
+import {
+  PrivateRoomUnlockResponseSchema,
+  type PrivateRoomUnlockReason,
+  type PrivateRoomUnlockResponseData,
+  type PrivateRoomUnlockResponseInput,
+} from "@/data/schemas/private-room";
+
+import { PrivateRoomMoment } from "../private_room_moment";
+
+export class PrivateRoomUnlockResponse extends PrivateRoomMoment {
+  declare readonly reason: PrivateRoomUnlockReason | string;
+  declare readonly creditsCharged: number;
+  declare readonly creditBalance: number;
+  declare readonly previousCreditBalance: number;
+  declare readonly currentCredits: number;
+  declare readonly shortfallCredits: number;
+  declare readonly persisted: boolean;
+
+  private constructor(input: PrivateRoomUnlockResponseInput) {
+    const data = PrivateRoomUnlockResponseSchema.parse(input);
+    super(data, false);
+    Object.assign(this, data);
+    Object.freeze(this);
+  }
+
+  static override from(
+    input: PrivateRoomUnlockResponseInput,
+  ): PrivateRoomUnlockResponse {
+    return new PrivateRoomUnlockResponse(input);
+  }
+
+  static override fromJson(json: unknown): PrivateRoomUnlockResponse {
+    return PrivateRoomUnlockResponse.from(
+      json as PrivateRoomUnlockResponseInput,
+    );
+  }
+
+  override toJson(): PrivateRoomUnlockResponseData {
+    return PrivateRoomUnlockResponseSchema.parse(this);
+  }
+}

src/data/repositories/index.ts

@@ -6,9 +6,11 @@ export * from "./auth_repository";
 export * from "./chat_repository";
 export * from "./metrics_repository";
 export * from "./payment_repository";
+export * from "./private_room_repository";
 export * from "./user_repository";
 export * from "./interfaces/iauth_repository";
 export * from "./interfaces/ichat_repository";
 export * from "./interfaces/imetrics_repository";
 export * from "./interfaces/ipayment_repository";
+export * from "./interfaces/iprivate_room_repository";
 export * from "./interfaces/iuser_repository";

src/data/repositories/interfaces/index.ts

@@ -6,4 +6,5 @@ export * from "./iauth_repository";
 export * from "./ichat_repository";
 export * from "./imetrics_repository";
 export * from "./ipayment_repository";
+export * from "./iprivate_room_repository";
 export * from "./iuser_repository";

src/data/repositories/interfaces/iprivate_room_repository.ts

@@ -0,0 +1,22 @@
+import type {
+  PrivateRoomMomentsResponse,
+  PrivateRoomUnlockResponse,
+} from "@/data/dto/private-room";
+import type { Result } from "@/utils/result";
+
+export interface GetPrivateRoomMomentsInput {
+  character?: string;
+  limit?: number;
+  cursor?: string | null;
+}
+
+export interface IPrivateRoomRepository {
+  getMoments(
+    input?: GetPrivateRoomMomentsInput,
+  ): Promise<Result<PrivateRoomMomentsResponse>>;
+
+  unlockMoment(
+    momentId: string,
+    expectedCost: number,
+  ): Promise<Result<PrivateRoomUnlockResponse>>;
+}

src/data/repositories/private_room_repository.ts

@@ -0,0 +1,45 @@
+"use client";
+
+import {
+  UnlockPrivateRoomMomentRequest,
+  type PrivateRoomMomentsResponse,
+  type PrivateRoomUnlockResponse,
+} from "@/data/dto/private-room";
+import {
+  PrivateRoomApi,
+  privateRoomApi,
+} from "@/data/services/api/private_room_api";
+import type {
+  GetPrivateRoomMomentsInput,
+  IPrivateRoomRepository,
+} from "@/data/repositories/interfaces";
+import { Result } from "@/utils/result";
+
+import { createLazySingleton } from "./lazy_singleton";
+
+export class PrivateRoomRepository implements IPrivateRoomRepository {
+  constructor(private readonly api: PrivateRoomApi) {}
+
+  getMoments(
+    input: GetPrivateRoomMomentsInput = {},
+  ): Promise<Result<PrivateRoomMomentsResponse>> {
+    return Result.wrap(() => this.api.getMoments(input));
+  }
+
+  unlockMoment(
+    momentId: string,
+    expectedCost: number,
+  ): Promise<Result<PrivateRoomUnlockResponse>> {
+    return Result.wrap(() =>
+      this.api.unlockMoment(
+        momentId,
+        UnlockPrivateRoomMomentRequest.from({ expectedCost }),
+      ),
+    );
+  }
+}
+
+export const getPrivateRoomRepository =
+  createLazySingleton<IPrivateRoomRepository>(
+    () => new PrivateRoomRepository(privateRoomApi),
+  );

src/data/schemas/private-room/index.ts

@@ -0,0 +1,4 @@
+export * from "./private_room";
+export * from "./private_room_moments_response";
+export * from "./private_room_unlock_response";
+export * from "./unlock_private_room_moment_request";

src/data/schemas/private-room/private_room.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+
+import {
+  arrayOrEmpty,
+  booleanOrFalse,
+  numberOrZero,
+  schemaOr,
+  stringOrEmpty,
+  stringOrNull,
+} from "../nullable-defaults";
+
+export const PrivateRoomProfileSchema = z.object({
+  characterId: stringOrEmpty,
+  displayName: stringOrEmpty,
+  authorName: stringOrEmpty,
+  avatarUrl: stringOrNull,
+  coverUrl: stringOrNull,
+  title: stringOrEmpty,
+  subtitle: stringOrEmpty,
+});
+
+export const PrivateRoomImageSchema = z.object({
+  url: stringOrNull,
+  type: stringOrEmpty,
+  locked: booleanOrFalse,
+  index: numberOrZero,
+});
+
+export const PrivateRoomLockDetailSchema = z.object({
+  locked: booleanOrFalse,
+  showContent: booleanOrFalse,
+  showUpgrade: booleanOrFalse,
+  reason: stringOrNull,
+  hint: stringOrNull,
+  actionLabel: stringOrNull,
+  type: stringOrNull,
+  requiredCredits: numberOrZero,
+  currentCredits: numberOrZero,
+  shortfallCredits: numberOrZero,
+  mediaCount: numberOrZero,
+  unlockCostPerImage: numberOrZero,
+  detail: z.unknown().nullable().default(null),
+});
+
+export const PrivateRoomAuthorSchema = z.object({
+  id: stringOrEmpty,
+  name: stringOrEmpty,
+  avatarUrl: stringOrNull,
+});
+
+export const PrivateRoomMomentSchema = z.object({
+  momentId: stringOrEmpty,
+  source: stringOrEmpty,
+  sourceId: stringOrEmpty,
+  characterId: stringOrEmpty,
+  author: schemaOr(PrivateRoomAuthorSchema, {
+    id: "",
+    name: "",
+    avatarUrl: null,
+  }),
+  createdAt: stringOrNull,
+  publishedAt: stringOrNull,
+  timeText: stringOrEmpty,
+  title: stringOrEmpty,
+  content: stringOrNull,
+  text: stringOrNull,
+  textPreview: stringOrEmpty,
+  mediaCount: numberOrZero,
+  images: arrayOrEmpty(PrivateRoomImageSchema),
+  locked: booleanOrFalse,
+  unlocked: booleanOrFalse,
+  unlockCost: numberOrZero,
+  unlockCostPerImage: numberOrZero,
+  requiredCredits: numberOrZero,
+  currency: stringOrEmpty,
+  lockDetail: schemaOr(PrivateRoomLockDetailSchema, {
+    locked: false,
+    showContent: false,
+    showUpgrade: false,
+    reason: null,
+    hint: null,
+    actionLabel: null,
+    type: null,
+    requiredCredits: 0,
+    currentCredits: 0,
+    shortfallCredits: 0,
+    mediaCount: 0,
+    unlockCostPerImage: 0,
+    detail: null,
+  }),
+});
+
+export type PrivateRoomProfileData = z.output<
+  typeof PrivateRoomProfileSchema
+>;
+export type PrivateRoomImageData = z.output<typeof PrivateRoomImageSchema>;
+export type PrivateRoomLockDetailData = z.output<
+  typeof PrivateRoomLockDetailSchema
+>;
+export type PrivateRoomAuthorData = z.output<typeof PrivateRoomAuthorSchema>;
+export type PrivateRoomMomentInput = z.input<typeof PrivateRoomMomentSchema>;
+export type PrivateRoomMomentData = z.output<typeof PrivateRoomMomentSchema>;

src/data/schemas/private-room/private_room_moments_response.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+
+import {
+  arrayOrEmpty,
+  booleanOrFalse,
+  numberOrZero,
+  schemaOr,
+  stringOrEmpty,
+  stringOrNull,
+} from "../nullable-defaults";
+import {
+  PrivateRoomMomentSchema,
+  PrivateRoomProfileSchema,
+} from "./private_room";
+
+export const PrivateRoomMomentsResponseSchema = z.object({
+  profile: schemaOr(PrivateRoomProfileSchema, {
+    characterId: "elio",
+    displayName: "Elio Silvestri",
+    authorName: "Elio Silvestri",
+    avatarUrl: null,
+    coverUrl: null,
+    title: "Elio Private room",
+    subtitle: "Join me, unlock my private room",
+  }),
+  items: arrayOrEmpty(PrivateRoomMomentSchema),
+  nextCursor: stringOrNull,
+  hasMore: booleanOrFalse,
+  creditBalance: numberOrZero,
+  unlockCostDefault: numberOrZero,
+  unlockCostPerImage: numberOrZero,
+  currency: stringOrEmpty,
+  source: stringOrEmpty,
+});
+
+export type PrivateRoomMomentsResponseInput = z.input<
+  typeof PrivateRoomMomentsResponseSchema
+>;
+export type PrivateRoomMomentsResponseData = z.output<
+  typeof PrivateRoomMomentsResponseSchema
+>;

src/data/schemas/private-room/private_room_unlock_response.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+import { booleanOrFalse, numberOrZero, stringOrEmpty } from "../nullable-defaults";
+import { PrivateRoomMomentSchema } from "./private_room";
+
+export const PrivateRoomUnlockReasonSchema = z.enum([
+  "ok",
+  "already_unlocked",
+  "insufficient_credits",
+  "cost_changed",
+  "not_found",
+  "no_media",
+  "deduct_failed",
+  "ok_persist_failed",
+]);
+
+export const PrivateRoomUnlockResponseSchema =
+  PrivateRoomMomentSchema.extend({
+    reason: PrivateRoomUnlockReasonSchema.or(stringOrEmpty),
+    creditsCharged: numberOrZero,
+    creditBalance: numberOrZero,
+    previousCreditBalance: numberOrZero,
+    currentCredits: numberOrZero,
+    shortfallCredits: numberOrZero,
+    persisted: booleanOrFalse,
+  });
+
+export type PrivateRoomUnlockReason = z.output<
+  typeof PrivateRoomUnlockReasonSchema
+>;
+export type PrivateRoomUnlockResponseInput = z.input<
+  typeof PrivateRoomUnlockResponseSchema
+>;
+export type PrivateRoomUnlockResponseData = z.output<
+  typeof PrivateRoomUnlockResponseSchema
+>;

src/data/schemas/private-room/unlock_private_room_moment_request.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+import { numberOrZero } from "../nullable-defaults";
+
+export const UnlockPrivateRoomMomentRequestSchema = z.object({
+  expectedCost: numberOrZero,
+});
+
+export type UnlockPrivateRoomMomentRequestInput = z.input<
+  typeof UnlockPrivateRoomMomentRequestSchema
+>;
+export type UnlockPrivateRoomMomentRequestData = z.output<
+  typeof UnlockPrivateRoomMomentRequestSchema
+>;

src/data/services/api/api_path.ts

@@ -14,6 +14,7 @@ export class ApiPath {
   private static readonly _user = `${ApiPath._baseUrl}/user`;
   private static readonly _payment = `${ApiPath._baseUrl}/payment`;
   private static readonly _chat = `${ApiPath._baseUrl}/chat`;
+  private static readonly _privateRoom = `${ApiPath._baseUrl}/private-room`;
 
   // ============ 认证相关 ============
   /** 邮箱密码登录 */
@@ -73,6 +74,15 @@ export class ApiPath {
   /** 一键解锁历史锁定消息 */
   static readonly chatUnlockHistory = `${ApiPath._chat}/unlock-history`;
 
+  // ============ 私密空间相关 ============
+  /** 获取私密空间动态列表 */
+  static readonly privateRoomMoments = `${ApiPath._privateRoom}/moments`;
+
+  /** 解锁私密空间动态 */
+  static privateRoomMomentUnlock(momentId: string): string {
+    return `${ApiPath.privateRoomMoments}/${encodeURIComponent(momentId)}/unlock`;
+  }
+
   // ============ 数据看板相关 ============
   private static readonly _metrics = `${ApiPath._baseUrl}/metrics`;
 

src/data/services/api/index.ts

@@ -9,5 +9,6 @@ export * from "./chat_api";
 export * from "./http_client";
 export * from "./metrics_api";
 export * from "./payment_api";
+export * from "./private_room_api";
 export * from "./response_helper";
 export * from "./user_api";

src/data/services/api/private_room_api.ts

@@ -0,0 +1,49 @@
+import {
+  PrivateRoomMomentsResponse,
+  PrivateRoomUnlockResponse,
+  UnlockPrivateRoomMomentRequest,
+} from "@/data/dto/private-room";
+
+import { ApiPath } from "./api_path";
+import { httpClient } from "./http_client";
+import { type ApiEnvelope, unwrap } from "./response_helper";
+
+export interface GetPrivateRoomMomentsInput {
+  character?: string;
+  limit?: number;
+  cursor?: string | null;
+}
+
+export class PrivateRoomApi {
+  async getMoments(
+    input: GetPrivateRoomMomentsInput = {},
+  ): Promise<PrivateRoomMomentsResponse> {
+    const env = await httpClient<ApiEnvelope<unknown>>(
+      ApiPath.privateRoomMoments,
+      {
+        query: {
+          character: input.character ?? "elio",
+          limit: input.limit ?? 20,
+          ...(input.cursor ? { cursor: input.cursor } : {}),
+        },
+      },
+    );
+    return PrivateRoomMomentsResponse.fromJson(unwrap(env));
+  }
+
+  async unlockMoment(
+    momentId: string,
+    body: UnlockPrivateRoomMomentRequest,
+  ): Promise<PrivateRoomUnlockResponse> {
+    const env = await httpClient<ApiEnvelope<unknown>>(
+      ApiPath.privateRoomMomentUnlock(momentId),
+      {
+        method: "POST",
+        body: body.toJson(),
+      },
+    );
+    return PrivateRoomUnlockResponse.fromJson(unwrap(env));
+  }
+}
+
+export const privateRoomApi = new PrivateRoomApi();