cime-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,768 @@
+import axios from 'axios';
+import axiosRetry from 'axios-retry';
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+
+// src/utils/version.ts
+
+// package.json
+var package_default = {
+  name: "cime-sdk",
+  version: "1.0.0",
+  description: "A structural and object-oriented TypeScript SDK for ci.me API",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  files: [
+    "dist"
+  ],
+  exports: {
+    ".": {
+      require: "./dist/index.js",
+      import: "./dist/index.mjs",
+      types: "./dist/index.d.ts"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest",
+    typecheck: "tsc --noEmit"
+  },
+  keywords: ["cime", "sdk", "typescript"],
+  author: "whitespaca",
+  license: "MIT",
+  repository: { type: "git", url: "https://github.com/whitespaca/cime-sdk" },
+  type: "commonjs",
+  dependencies: {
+    axios: "^1.15.0",
+    "axios-retry": "^4.5.0",
+    ws: "^8.20.0"
+  },
+  devDependencies: {
+    "@types/node": "^25.6.0",
+    "@types/ws": "^8.18.1",
+    tsup: "^8.5.1",
+    typescript: "^6.0.2",
+    vitest: "^4.1.4"
+  }
+};
+
+// src/utils/version.ts
+function getVersion() {
+  return package_default.version;
+}
+async function checkVersion() {
+  try {
+    const localVersion = package_default.version;
+    const packageName = package_default.name;
+    const { data, status } = await axios.get(`https://registry.npmjs.org/${packageName}/latest`, {
+      timeout: 3e3
+    });
+    if (status !== 200 || !data || !data.version) {
+      return;
+    }
+    const remoteVersion = data.version;
+    if (isNewerVersion(localVersion, remoteVersion)) {
+      console.log(`
+======================================================`);
+      console.log(`\u{1F680} [CIME SDK] \uC0C8\uB85C\uC6B4 \uBC84\uC804\uC744 \uCC3E\uC558\uC2B5\uB2C8\uB2E4!`);
+      console.log(`\uD604\uC7AC \uBC84\uC804: ${localVersion} -> \uCD5C\uC2E0 \uBC84\uC804: ${remoteVersion}`);
+      console.log(`UPDATE: npm install ${packageName}@${remoteVersion}`);
+      console.log(`======================================================
+`);
+    }
+  } catch (error) {
+    return;
+  }
+}
+function isNewerVersion(local, remote) {
+  const lParts = local.split(".").map(Number);
+  const rParts = remote.split(".").map(Number);
+  const maxLength = Math.max(lParts.length, rParts.length);
+  for (let i = 0; i < maxLength; i++) {
+    const l = lParts[i] || 0;
+    const r = rParts[i] || 0;
+    if (r > l) return true;
+    if (r < l) return false;
+  }
+  return false;
+}
+
+// src/errors/CimeAPIError.ts
+var CimeAPIError = class _CimeAPIError extends Error {
+  statusCode;
+  /**
+   * @param errorResponse - API 서버에서 반환한 에러 객체
+   */
+  constructor(errorResponse) {
+    super(errorResponse.message);
+    this.name = "CimeAPIError";
+    this.statusCode = errorResponse.statusCode;
+    Object.setPrototypeOf(this, _CimeAPIError.prototype);
+  }
+};
+
+// src/utils/httpClient.ts
+function createHttpClient(options) {
+  const client = axios.create({
+    baseURL: "https://ci.me/api/openapi",
+    timeout: options.timeout || 1e4,
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": `CimeSDK/${getVersion()} (Node)`
+    }
+  });
+  client.interceptors.request.use((config) => {
+    if (options.accessToken) {
+      config.headers["Authorization"] = `Bearer ${options.accessToken}`;
+    }
+    if (options.clientId && options.clientSecret) {
+      config.headers["Client-Id"] = options.clientId;
+      config.headers["Client-Secret"] = options.clientSecret;
+    }
+    return config;
+  });
+  axiosRetry(client, {
+    retries: options.retries ?? 3,
+    retryDelay: axiosRetry.exponentialDelay,
+    retryCondition: (error) => {
+      return axiosRetry.isNetworkOrIdempotentRequestError(error) || error.response?.status === 500;
+    }
+  });
+  client.interceptors.response.use(
+    (response) => {
+      return response.data.content;
+    },
+    (error) => {
+      if (error.response && error.response.data) {
+        throw new CimeAPIError(error.response.data);
+      }
+      throw error;
+    }
+  );
+  return client;
+}
+
+// src/api/auth.ts
+var AuthAPI = class {
+  constructor(http, config) {
+    this.http = http;
+    this.config = config;
+  }
+  http;
+  config;
+  /**
+   * Authorization Code를 사용하여 Access Token과 Refresh Token을 발급받습니다.
+   * @param code Redirect URI로 전달받은 인가 코드
+   */
+  async get(code) {
+    this.validateCredentials();
+    const { data } = await this.http.post("/api/openapi/auth/v1/token", {
+      grantType: "authorization_code",
+      clientId: this.config.clientId,
+      clientSecret: this.config.clientSecret,
+      code
+    });
+    return data;
+  }
+  /**
+   * Refresh Token을 사용하여 Access Token을 갱신합니다.
+   * @param refreshToken 이전에 발급받은 리프레시 토큰
+   */
+  async refresh(refreshToken) {
+    this.validateCredentials();
+    const { data } = await this.http.post("/api/openapi/auth/v1/token", {
+      grantType: "refresh_token",
+      clientId: this.config.clientId,
+      clientSecret: this.config.clientSecret,
+      refreshToken
+    });
+    return data;
+  }
+  /**
+   * 내부 헬퍼: 토큰 발급 시 필요한 Client ID 및 Secret 유효성 검사 (Fail-fast)
+   */
+  validateCredentials() {
+    if (!this.config.clientId || !this.config.clientSecret) {
+      throw new Error(
+        "[Cime SDK] OAuth \uD1A0\uD070\uC744 \uBC1C\uAE09/\uAC31\uC2E0\uD558\uB824\uBA74 \uCD08\uAE30\uD654 \uC2DC clientId\uC640 clientSecret\uC774 \uD544\uC694\uD569\uB2C8\uB2E4."
+      );
+    }
+  }
+};
+
+// src/api/users.ts
+var UsersAPI = class {
+  constructor(httpClient, options) {
+    this.httpClient = httpClient;
+    this.options = options;
+  }
+  httpClient;
+  options;
+  /**
+   * 현재 Access Token에 연결된 사용자의 채널 정보를 조회합니다.
+   *
+   * @requires Scope: `READ:USER`
+   * @throws {CimeAPIError} Access Token이 없거나 만료되었을 때 (401), 또는 권한이 부족할 때 발생합니다.
+   * @returns 사용자의 채널 상세 정보
+   * * @example
+   * ```typescript
+   * const me = await client.users.get();
+   * console.log(`안녕하세요, ${me.channelName}님!`);
+   * ```
+   */
+  async get() {
+    if (!this.options.scopes?.includes("READ:USER")) {
+      throw new Error('[UsersAPI] "READ:USER" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.get("/open/v1/users/me");
+  }
+};
+
+// src/api/channels.ts
+var ChannelsAPI = class {
+  constructor(httpClient, options) {
+    this.httpClient = httpClient;
+    this.options = options;
+  }
+  httpClient;
+  options;
+  /**
+   * 채널 ID 목록으로 채널의 기본 정보를 조회합니다. (최대 20개)
+   *
+   * @requires Auth: `Client ID / Secret` (공개 API)
+   * @param channelIds - 조회할 채널 ID 문자열 또는 ID 문자열의 배열
+   * @returns 채널 정보 목록
+   * * @example
+   * ```typescript
+   * const { data } = await client.channels.getChannels(['12345', '67890']);
+   * ```
+   */
+  async getChannels(channelIds) {
+    const parsedIds = Array.isArray(channelIds) ? channelIds.join(",") : channelIds;
+    return this.httpClient.get("/open/v1/channels", {
+      params: { channelIds: parsedIds }
+    });
+  }
+  /**
+   * 인증된 사용자 채널의 팔로워 목록을 조회합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `READ:CHANNEL`
+   * @param params - 페이징 파라미터 (page, size)
+   * @returns 팔로워 목록
+   */
+  async getFollowers(params) {
+    if (!this.options.scopes?.includes("READ:CHANNEL")) {
+      throw new Error('[ChannelsAPI] "READ:CHANNEL" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.get("/open/v1/channels/followers", {
+      params
+    });
+  }
+  /**
+   * 인증된 사용자 채널의 구독자 목록을 조회합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `READ:SUBSCRIPTION`
+   * @param params - 페이징 및 정렬 파라미터 (page, size, sort)
+   * @returns 구독자 목록
+   */
+  async getSubscribers(params) {
+    if (!this.options.scopes?.includes("READ:SUBSCRIPTION")) {
+      throw new Error('[ChannelsAPI] "READ:SUBSCRIPTION" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.get("/open/v1/channels/subscribers", {
+      params
+    });
+  }
+  /**
+   * 인증된 사용자 채널의 관리자 목록을 조회합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `READ:CHANNEL`
+   * @returns 관리자 목록
+   */
+  async getManagers() {
+    if (!this.options.scopes?.includes("READ:CHANNEL")) {
+      throw new Error('[ChannelsAPI] "READ:CHANNEL" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.get("/open/v1/channels/streaming-roles");
+  }
+};
+
+// src/api/live.ts
+var LiveAPI = class {
+  constructor(httpClient, options) {
+    this.httpClient = httpClient;
+    this.options = options;
+  }
+  httpClient;
+  options;
+  /**
+   * 현재 진행 중인 라이브 방송 목록을 조회합니다.
+   *
+   * @requires Auth: `Client ID / Secret` (공개 API)
+   * @param params - 커서 기반 페이징 파라미터 (size, next)
+   * @returns 라이브 목록과 다음 페이지 커서 정보
+   */
+  async getLives(params) {
+    return this.httpClient.get("/open/v1/lives", {
+      params
+    });
+  }
+  /**
+   * 인증된 사용자 채널의 라이브 설정을 조회합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `READ:LIVE_STREAM_SETTINGS`
+   * @returns 라이브 설정 정보
+   */
+  async getSettings() {
+    if (!this.options.scopes?.includes("READ:LIVE_STREAM_SETTINGS")) {
+      throw new Error('[LiveAPI] "READ:LIVE_STREAM_SETTINGS" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.get("/open/v1/lives/setting");
+  }
+  /**
+   * 인증된 사용자 채널의 라이브 설정을 변경합니다. (전달된 필드만 업데이트)
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `WRITE:LIVE_STREAM_SETTINGS`
+   * @param params - 변경할 라이브 설정 데이터
+   */
+  async updateSettings(params) {
+    if (!this.options.scopes?.includes("WRITE:LIVE_STREAM_SETTINGS")) {
+      throw new Error('[LiveAPI] "WRITE:LIVE_STREAM_SETTINGS" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    await this.httpClient.patch("/open/v1/lives/setting", params);
+  }
+  /**
+   * 인증된 사용자 채널의 스트림 키(Stream Key)를 조회합니다.
+   * OBS 등 외부 방송 도구 연동 시 사용됩니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `READ:LIVE_STREAM_KEY`
+   * @returns 스트림 키
+   */
+  async getStreamKey() {
+    if (!this.options.scopes?.includes("READ:LIVE_STREAM_KEY")) {
+      throw new Error('[LiveAPI] "READ:LIVE_STREAM_KEY" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.get("/open/v1/streams/key");
+  }
+  /**
+   * 특정 채널의 라이브 방송 여부와 상태를 확인합니다.
+   * 이 API는 인증 없이 호출할 수 있는 완전 공개 API입니다.
+   *
+   * @requires Auth: 불필요
+   * @param channelId - 상태를 조회할 채널의 ID
+   * @returns 라이브 상태 정보
+   */
+  async getLiveStatus(channelId) {
+    return this.httpClient.get(`/v1/${channelId}/live-status`);
+  }
+};
+
+// src/api/chat.ts
+var ChatAPI = class {
+  constructor(httpClient, options) {
+    this.httpClient = httpClient;
+    this.options = options;
+  }
+  httpClient;
+  options;
+  /**
+   * 인증된 사용자 채널의 채팅 설정을 조회합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `READ:LIVE_CHAT_SETTINGS`
+   * @returns 채팅 설정 정보
+   */
+  async getSettings() {
+    if (!this.options.scopes?.includes("READ:LIVE_CHAT_SETTINGS")) {
+      throw new Error('[ChatAPI] "READ:LIVE_CHAT_SETTINGS" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.get("/open/v1/chats/settings");
+  }
+  /**
+   * 인증된 사용자 채널의 채팅 설정을 변경합니다. (전달된 필드만 업데이트)
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `WRITE:LIVE_CHAT_SETTINGS`
+   * @param params - 변경할 채팅 설정 데이터
+   */
+  async updateSettings(params) {
+    if (!this.options.scopes?.includes("WRITE:LIVE_CHAT_SETTINGS")) {
+      throw new Error('[ChatAPI] "WRITE:LIVE_CHAT_SETTINGS" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    await this.httpClient.put("/open/v1/chats/settings", params);
+  }
+  /**
+   * 인증된 사용자의 채널 라이브 채팅에 메시지를 전송합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `WRITE:LIVE_CHAT`
+   * @param params - 전송할 메시지 정보 및 발신자 타입
+   * @returns 전송된 메시지 ID
+   */
+  async sendMessage(params) {
+    if (!this.options.scopes?.includes("WRITE:LIVE_CHAT")) {
+      throw new Error('[ChatAPI] "WRITE:LIVE_CHAT" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.post("/open/v1/chats/send", params);
+  }
+  /**
+   * 인증된 사용자의 채널 라이브 채팅에 공지사항을 등록합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `WRITE:LIVE_CHAT_NOTICE`
+   * @param params - 등록할 공지 메시지 내용 또는 기존 메시지 ID
+   * @throws {Error} 파라미터가 모두 누락된 경우 서버 요청 전 사전 차단합니다.
+   */
+  async registerNotice(params) {
+    if (!this.options.scopes?.includes("WRITE:LIVE_CHAT_NOTICE")) {
+      throw new Error('[ChatAPI] "WRITE:LIVE_CHAT_NOTICE" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    if (!params.message && !params.messageId) {
+      throw new Error('[CimeClient.ChatAPI] registerNotice requires either "message" or "messageId".');
+    }
+    await this.httpClient.post("/open/v1/chats/notice", params);
+  }
+};
+
+// src/api/categories.ts
+var CategoriesAPI = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  httpClient;
+  /**
+   * 라이브 설정 등에 사용할 카테고리를 키워드로 검색합니다.
+   *
+   * @requires Auth: `Client ID / Secret` (공개 API)
+   * @param params - 검색 키워드 및 페이지 크기 파라미터
+   * @returns 검색된 카테고리 목록
+   */
+  async searchCategories(params) {
+    return this.httpClient.get("/open/v1/categories/search", {
+      params
+    });
+  }
+};
+
+// src/api/restrict.ts
+var RestrictAPI = class {
+  constructor(httpClient, options) {
+    this.httpClient = httpClient;
+    this.options = options;
+  }
+  httpClient;
+  options;
+  /**
+   * 인증된 사용자의 채널에서 특정 사용자를 추방합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `WRITE:USER_BLOCK`
+   * @param params - 추방할 대상 채널 ID
+   */
+  async restrictUser(params) {
+    if (!this.options.scopes?.includes("WRITE:USER_BLOCK")) {
+      throw new Error('[RestrictAPI] "WRITE:USER_BLOCK" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    await this.httpClient.post("/open/v1/restrict-channels", params);
+  }
+  /**
+   * 인증된 사용자의 채널에서 추방된 사용자 목록을 조회합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `READ:USER_BLOCK`
+   * @param params - 커서 기반 페이징 파라미터 (size, next)
+   * @returns 추방된 사용자 목록
+   */
+  async getRestrictedUsers(params) {
+    if (!this.options.scopes?.includes("READ:USER_BLOCK")) {
+      throw new Error('[RestrictAPI] "READ:USER_BLOCK" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    return this.httpClient.get("/open/v1/restrict-channels", {
+      params
+    });
+  }
+  /**
+   * 인증된 사용자의 채널에서 특정 사용자의 추방을 해제합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @requires Scope: `WRITE:USER_BLOCK`
+   * @param params - 추방 해제할 대상 채널 ID
+   */
+  async unrestrictUser(params) {
+    if (!this.options.scopes?.includes("WRITE:USER_BLOCK")) {
+      throw new Error('[RestrictAPI] "WRITE:USER_BLOCK" \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. OAuth \uC778\uC99D \uC2DC \uD574\uB2F9 \uAD8C\uD55C\uC744 \uD3EC\uD568\uC2DC\uCF1C \uC8FC\uC138\uC694.');
+    }
+    await this.httpClient.delete("/open/v1/restrict-channels", {
+      data: params
+    });
+  }
+};
+
+// src/api/sessions.ts
+var SessionsAPI = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  httpClient;
+  /**
+   * WebSocket 연결을 위한 새로운 세션을 생성합니다.
+   *
+   * @param type - 세션 유형 ('USER' 또는 'CLIENT')
+   * @returns WebSocket URL을 포함한 세션 정보
+   */
+  async createSession(type) {
+    const endpoint = type === "USER" ? "/open/v1/sessions/auth" : "/open/v1/sessions/auth/client";
+    return this.httpClient.get(endpoint);
+  }
+  /**
+   * 특정 세션에 이벤트를 구독합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @param event - 구독할 이벤트 이름 (chat, donation, subscription)
+   * @param sessionKey - 세션 키
+   */
+  async subscribeEvent(event, sessionKey) {
+    await this.httpClient.post(`/open/v1/sessions/events/subscribe/${event}`, null, {
+      params: { sessionKey }
+    });
+  }
+  /**
+   * 특정 세션에서 이벤트 구독을 해제합니다.
+   *
+   * @requires Auth: `Access Token`
+   * @param event - 구독 해제할 이벤트 이름
+   * @param sessionKey - 세션 키
+   */
+  async unsubscribeEvent(event, sessionKey) {
+    await this.httpClient.post(`/open/v1/sessions/events/unsubscribe/${event}`, null, {
+      params: { sessionKey }
+    });
+  }
+};
+var CimeEventClient = class extends EventEmitter {
+  constructor(sessionsApi, options) {
+    super();
+    this.sessionsApi = sessionsApi;
+    this.options = options;
+  }
+  sessionsApi;
+  options;
+  ws = null;
+  sessionKey = null;
+  pingTimer = null;
+  reconnectTimer = null;
+  isConnecting = false;
+  isIntentionalClose = false;
+  activeSubscriptions = /* @__PURE__ */ new Set();
+  async connect() {
+    if (this.isConnecting || this.ws?.readyState === WebSocket.OPEN) return;
+    this.isConnecting = true;
+    this.isIntentionalClose = false;
+    try {
+      const { url } = await this.sessionsApi.createSession(this.options.type);
+      const parsedUrl = new URL(url);
+      this.sessionKey = parsedUrl.searchParams.get("sessionKey");
+      if (!this.sessionKey) {
+        throw new Error("[CimeEventClient] Failed to extract sessionKey from URL.");
+      }
+      this.ws = new WebSocket(url);
+      this.ws.on("open", async () => {
+        this.isConnecting = false;
+        this.startPing();
+        this.emit("connected");
+        for (const event of this.activeSubscriptions) {
+          const apiEventName = event.toLowerCase();
+          await this.sessionsApi.subscribeEvent(apiEventName, this.sessionKey).catch((err) => {
+            this.emit("error", new Error(`Failed to resubscribe ${event}: ${err.message}`));
+          });
+        }
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data.toString());
+      });
+      this.ws.on("close", () => {
+        this.cleanup();
+        this.emit("disconnected");
+        this.handleReconnect();
+      });
+      this.ws.on("error", (error) => {
+        this.emit("error", error);
+      });
+    } catch (error) {
+      this.isConnecting = false;
+      this.emit("error", error);
+      this.handleReconnect();
+    }
+  }
+  /**
+   * 실시간 이벤트를 구독합니다.
+   * @param event - 'CHAT' | 'DONATION' | 'SUBSCRIPTION'
+   */
+  async subscribe(event) {
+    if (this.activeSubscriptions.size >= 30) {
+      throw new Error("[CimeEventClient] Exceeded maximum 30 subscriptions per session.");
+    }
+    this.activeSubscriptions.add(event);
+    const apiEventName = event.toLowerCase();
+    if (this.sessionKey && this.ws?.readyState === WebSocket.OPEN) {
+      await this.sessionsApi.subscribeEvent(apiEventName, this.sessionKey);
+    }
+  }
+  /**
+   * 실시간 이벤트 구독을 해제합니다.
+   * @param event - 'CHAT' | 'DONATION' | 'SUBSCRIPTION'
+   */
+  async unsubscribe(event) {
+    this.activeSubscriptions.delete(event);
+    const apiEventName = event.toLowerCase();
+    if (this.sessionKey && this.ws?.readyState === WebSocket.OPEN) {
+      await this.sessionsApi.unsubscribeEvent(apiEventName, this.sessionKey);
+    }
+  }
+  disconnect() {
+    this.isIntentionalClose = true;
+    this.activeSubscriptions.clear();
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  handleMessage(message) {
+    try {
+      const payload = JSON.parse(message);
+      if (payload.action === "PONG") return;
+      if (payload.event && payload.data) {
+        const typedPayload = payload;
+        this.emit(typedPayload.event, typedPayload.data);
+      }
+    } catch (error) {
+      this.emit("error", new Error(`[CimeEventClient] Failed to parse message: ${message}`));
+    }
+  }
+  startPing() {
+    const interval = this.options.pingInterval || 6e4;
+    this.pingTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: "PING" }));
+      }
+    }, interval);
+  }
+  cleanup() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.isConnecting = false;
+  }
+  async handleReconnect() {
+    if (this.isIntentionalClose) return;
+    if (this.options.onTokenRefresh) {
+      try {
+        await this.options.onTokenRefresh();
+      } catch (err) {
+        this.emit("error", new Error("[CimeEventClient] Token refresh failed during reconnect."));
+      }
+    }
+    this.reconnectTimer = setTimeout(() => {
+      this.emit("reconnecting");
+      this.connect();
+    }, 5e3);
+  }
+};
+
+// src/client.ts
+var CimeClient = class {
+  httpClient;
+  options;
+  auth;
+  users;
+  channels;
+  live;
+  chat;
+  categories;
+  restrict;
+  sessions;
+  constructor(options) {
+    if (!options.accessToken && (!options.clientId || !options.clientSecret)) {
+      throw new Error("[CimeClient] Authentication credentials (accessToken OR clientId/Secret) are required.");
+    }
+    this.options = { ...options };
+    this.httpClient = createHttpClient(this.options);
+    this.auth = new AuthAPI(this.httpClient, { clientId: this.options.clientId, clientSecret: this.options.clientSecret });
+    this.users = new UsersAPI(this.httpClient, this.options);
+    this.channels = new ChannelsAPI(this.httpClient, this.options);
+    this.live = new LiveAPI(this.httpClient, this.options);
+    this.chat = new ChatAPI(this.httpClient, this.options);
+    this.categories = new CategoriesAPI(this.httpClient);
+    this.restrict = new RestrictAPI(this.httpClient, this.options);
+    this.sessions = new SessionsAPI(this.httpClient);
+  }
+  setAccessToken(token) {
+    this.options.accessToken = token;
+  }
+  /**
+   * 실시간 이벤트를 수신하기 위한 WebSocket 클라이언트를 생성합니다.
+   */
+  createEventClient(options) {
+    if (options.refreshToken && !options.onTokenRefresh) {
+      options.onTokenRefresh = async () => {
+        try {
+          const tokenInfo = await this.auth.refresh(options.refreshToken);
+          this.setAccessToken(tokenInfo.accessToken);
+          options.refreshToken = tokenInfo.refreshToken;
+        } catch (error) {
+          throw new Error("\uC790\uB3D9 \uD1A0\uD070 \uAC31\uC2E0\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.");
+        }
+      };
+    }
+    return new CimeEventClient(this.sessions, options);
+  }
+  /** * OAuth 인증 플로우를 통해 Access Token을 발급받고 클라이언트에 설정합니다.
+   * @param code Redirect URI로 전달받은 인가 코드
+   * @throws 인증 정보(clientId/Secret)가 없으면 에러를 반환합니다.
+   */
+  async authorize(code) {
+    if (!this.options.clientId || !this.options.clientSecret) {
+      throw new Error("[CimeClient] OAuth authentication requires clientId and clientSecret to be set in options.");
+    }
+    const tokenResponse = await this.auth.get(code);
+    this.setAccessToken(tokenResponse.accessToken);
+    return tokenResponse;
+  }
+};
+
+// src/utils/chatUtils.ts
+function renderChatEmojisToHTML(data, className = "cime-emoji") {
+  if (!data.emojis || Object.keys(data.emojis).length === 0) {
+    return data.content;
+  }
+  let htmlMessage = data.content;
+  for (const [token, imageUrl] of Object.entries(data.emojis)) {
+    const escapedToken = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(escapedToken, "g");
+    htmlMessage = htmlMessage.replace(regex, () => {
+      return `<img src="${imageUrl}" alt="${token}" class="${className}" />`;
+    });
+  }
+  return htmlMessage;
+}
+
+// src/index.ts
+checkVersion();
+
+export { CimeAPIError, CimeClient, CimeEventClient, getVersion, renderChatEmojisToHTML };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map