connectbase-client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3346 @@
+declare class ApiError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+declare class AuthError extends Error {
+    constructor(message: string);
+}
+
+interface HttpClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    onTokenRefresh?: (tokens: {
+        accessToken: string;
+        refreshToken: string;
+    }) => void;
+    onAuthError?: (error: AuthError) => void;
+}
+interface RequestConfig {
+    skipAuth?: boolean;
+    headers?: Record<string, string>;
+}
+declare class HttpClient {
+    private config;
+    private isRefreshing;
+    private refreshPromise;
+    constructor(config: HttpClientConfig);
+    updateConfig(config: Partial<HttpClientConfig>): void;
+    setTokens(accessToken: string, refreshToken: string): void;
+    clearTokens(): void;
+    /**
+     * API Key가 설정되어 있는지 확인
+     */
+    hasApiKey(): boolean;
+    /**
+     * API Key 반환
+     */
+    getApiKey(): string | undefined;
+    /**
+     * Access Token 반환
+     */
+    getAccessToken(): string | undefined;
+    /**
+     * Base URL 반환
+     */
+    getBaseUrl(): string;
+    private refreshAccessToken;
+    private isTokenExpired;
+    private prepareHeaders;
+    private handleResponse;
+    get<T>(url: string, config?: RequestConfig): Promise<T>;
+    post<T>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    put<T>(url: string, data: unknown, config?: RequestConfig): Promise<T>;
+    patch<T>(url: string, data: unknown, config?: RequestConfig): Promise<T>;
+    delete<T>(url: string, config?: RequestConfig): Promise<T>;
+}
+
+interface SignUpRequest {
+    email: string;
+    password: string;
+    name?: string;
+}
+interface SignUpResponse {
+    access_token: string;
+    refresh_token: string;
+    user: UserInfo;
+}
+interface SignInRequest {
+    email: string;
+    password: string;
+}
+interface SignInResponse {
+    access_token: string;
+    refresh_token: string;
+    user: UserInfo;
+}
+interface AnonymousSignUpResponse {
+    access_token: string;
+    refresh_token: string;
+    anonymous_uid: string;
+}
+interface AnonymousSignInRequest {
+    anonymous_uid?: string;
+}
+interface AnonymousSignInResponse {
+    access_token: string;
+    refresh_token: string;
+    anonymous_uid?: string;
+}
+interface UserInfo {
+    id: string;
+    email: string;
+    name?: string;
+    email_verified: boolean;
+    created_at: string;
+    is_anonymous?: boolean;
+}
+/** 앱 멤버 게스트 가입 응답 */
+interface GuestMemberSignInResponse {
+    member_id: string;
+    access_token: string;
+    refresh_token: string;
+}
+/** 앱 멤버 회원가입 요청 */
+interface MemberSignUpRequest {
+    login_id: string;
+    password: string;
+    nickname?: string;
+}
+/** 앱 멤버 회원가입 응답 */
+interface MemberSignUpResponse {
+    member_id: string;
+    nickname: string;
+    access_token: string;
+    refresh_token: string;
+}
+/** 앱 멤버 로그인 요청 */
+interface MemberSignInRequest {
+    login_id: string;
+    password: string;
+}
+/** 앱 멤버 로그인 응답 */
+interface MemberSignInResponse {
+    member_id: string;
+    nickname: string;
+    access_token: string;
+    refresh_token: string;
+}
+/** 앱 인증 설정 응답 */
+interface AuthSettingsResponse {
+    /** 아이디/비밀번호 로그인 허용 여부 */
+    allow_id_password_login: boolean;
+    /** 게스트 로그인 허용 여부 */
+    allow_guest_login: boolean;
+    /** 활성화된 OAuth 프로바이더 목록 (GOOGLE, KAKAO, NAVER, APPLE, GITHUB, DISCORD) */
+    enabled_oauth_providers: string[];
+}
+
+declare class AuthAPI {
+    private http;
+    private anonymousLoginPromise;
+    private guestMemberLoginPromise;
+    private cachedAnonymousUIDKey;
+    private cachedGuestMemberTokenKey;
+    constructor(http: HttpClient);
+    /**
+     * 앱의 인증 설정 조회
+     * 어떤 로그인 방식이 허용되는지 확인합니다.
+     *
+     * @example
+     * ```typescript
+     * const settings = await client.auth.getAuthSettings()
+     * if (settings.allow_guest_login) {
+     *     await client.auth.signInAsGuestMember()
+     * } else if (settings.allow_id_password_login) {
+     *     // 로그인 폼 표시
+     * } else if (settings.enabled_oauth_providers.includes('GOOGLE')) {
+     *     // 구글 소셜 로그인 버튼 표시
+     * }
+     * ```
+     */
+    getAuthSettings(): Promise<AuthSettingsResponse>;
+    /**
+     * 현재 앱의 anonymous_uid 스토리지 키 생성
+     * apiKey를 해시하여 앱별 고유 키 생성 (원본 apiKey 노출 방지)
+     * 성능 최적화: 키를 캐싱하여 반복 해시 계산 방지
+     */
+    private getAnonymousUIDKey;
+    /**
+     * 회원가입
+     */
+    signUp(data: SignUpRequest): Promise<SignUpResponse>;
+    /**
+     * 로그인
+     */
+    signIn(data: SignInRequest): Promise<SignInResponse>;
+    /**
+     * 익명 로그인
+     * 계정 없이 게스트로 앱을 사용할 수 있습니다.
+     * 로컬 스토리지에 저장된 anonymous_uid가 있으면 기존 계정으로 재로그인을 시도합니다.
+     * 동시 호출 시 중복 요청 방지 (race condition 방지)
+     */
+    signInAnonymously(): Promise<AnonymousSignInResponse>;
+    /**
+     * 실제 익명 로그인 실행 (내부 메서드)
+     */
+    private executeAnonymousLogin;
+    /**
+     * 저장된 anonymous_uid 조회
+     */
+    getStoredAnonymousUID(): string | null;
+    /**
+     * anonymous_uid 저장
+     */
+    private storeAnonymousUID;
+    /**
+     * 저장된 anonymous_uid 삭제
+     */
+    clearAnonymousUID(): void;
+    /**
+     * 로그아웃
+     */
+    signOut(): Promise<void>;
+    /**
+     * 현재 사용자 정보 조회
+     * 토큰이 없거나 유효하지 않으면 자동으로 익명 계정을 생성합니다.
+     * @param autoAnonymous - 자동 익명 로그인 활성화 (기본값: false, 명시적으로 활성화 필요)
+     */
+    getCurrentUser(autoAnonymous?: boolean): Promise<UserInfo>;
+    /**
+     * 이메일 인증 메일 재발송
+     */
+    resendVerificationEmail(): Promise<void>;
+    /**
+     * 앱 멤버 게스트 가입
+     * API Key로 인증된 앱에 게스트 멤버로 가입합니다.
+     * 실시간 채팅 등에서 JWT 토큰 기반 인증이 필요할 때 사용합니다.
+     * 로컬 스토리지에 저장된 토큰이 있으면 기존 계정으로 재로그인을 시도합니다.
+     * 동시 호출 시 중복 요청 방지 (race condition 방지)
+     *
+     * @example
+     * ```typescript
+     * // 게스트로 가입하고 실시간 연결
+     * const guest = await client.auth.signInAsGuestMember()
+     * await client.realtime.connect({ accessToken: guest.access_token })
+     * ```
+     */
+    signInAsGuestMember(): Promise<GuestMemberSignInResponse>;
+    /**
+     * 실제 게스트 멤버 로그인 실행 (내부 메서드)
+     */
+    private executeGuestMemberLogin;
+    /**
+     * JWT 토큰 만료 여부 확인 (로컬 검증)
+     */
+    private isTokenExpired;
+    /**
+     * 현재 앱의 guest_member 토큰 스토리지 키 생성
+     */
+    private getGuestMemberTokenKey;
+    /**
+     * 저장된 게스트 멤버 토큰 조회
+     */
+    private getStoredGuestMemberTokens;
+    /**
+     * 게스트 멤버 토큰 저장
+     */
+    private storeGuestMemberTokens;
+    /**
+     * 저장된 게스트 멤버 토큰 삭제
+     */
+    clearGuestMemberTokens(): void;
+    /**
+     * 앱 멤버 회원가입 (이메일/ID 기반)
+     * 앱에 새로운 멤버를 등록합니다.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.auth.signUpMember({
+     *     login_id: 'user@example.com',
+     *     password: 'password123',
+     *     nickname: 'John'
+     * })
+     * console.log('가입 완료:', result.member_id)
+     * ```
+     */
+    signUpMember(data: MemberSignUpRequest): Promise<MemberSignUpResponse>;
+    /**
+     * 앱 멤버 로그인 (이메일/ID 기반)
+     * 기존 멤버로 로그인합니다.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.auth.signInMember({
+     *     login_id: 'user@example.com',
+     *     password: 'password123'
+     * })
+     * console.log('로그인 성공:', result.member_id)
+     * ```
+     */
+    signInMember(data: MemberSignInRequest): Promise<MemberSignInResponse>;
+}
+
+type DataType = 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array';
+interface ColumnSchema {
+    id: string;
+    name: string;
+    data_type: DataType;
+    is_required: boolean;
+    default_value?: string;
+    validation_rule?: string;
+    order: number;
+    created_at: string;
+    updated_at?: string;
+}
+interface CreateColumnRequest {
+    name: string;
+    data_type: DataType;
+    is_required: boolean;
+    default_value?: string;
+    validation_rule?: string;
+    order: number;
+}
+interface UpdateColumnRequest {
+    name?: string;
+    data_type?: DataType;
+    is_required?: boolean;
+    default_value?: string;
+    validation_rule?: string;
+    order?: number;
+}
+interface TableSchema {
+    id: string;
+    name: string;
+    description?: string;
+    columns: ColumnSchema[];
+    created_at: string;
+    updated_at?: string;
+}
+interface CreateTableRequest {
+    name: string;
+    description?: string;
+}
+interface DataItem {
+    id: string;
+    data: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateDataRequest {
+    data: Record<string, unknown>;
+}
+interface UpdateDataRequest {
+    data: Record<string, unknown>;
+}
+interface FetchDataResponse {
+    data: DataItem[];
+    total_count: number;
+    limit: number;
+    offset: number;
+}
+interface QueryOptions {
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    orderDirection?: 'asc' | 'desc';
+    where?: WhereCondition;
+}
+type WhereCondition = Record<string, unknown | WhereOperator>;
+interface WhereOperator {
+    $eq?: unknown;
+    $ne?: unknown;
+    $gt?: number;
+    $gte?: number;
+    $lt?: number;
+    $lte?: number;
+    $in?: unknown[];
+    $nin?: unknown[];
+    $contains?: string;
+    $startsWith?: string;
+    $endsWith?: string;
+}
+interface BulkCreateResponse {
+    created: DataItem[];
+    failed?: BulkError[];
+    total: number;
+    success: number;
+}
+interface BulkError {
+    index: number;
+    error: string;
+}
+interface DeleteWhereResponse {
+    deleted: number;
+}
+
+declare class DatabaseAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * API Key 인증 시 /v1/public 접두사 반환
+     */
+    private getPublicPrefix;
+    /**
+     * 테이블 목록 조회
+     */
+    getTables(databaseId: string): Promise<TableSchema[]>;
+    /**
+     * 테이블 생성
+     */
+    createTable(databaseId: string, data: CreateTableRequest): Promise<TableSchema>;
+    /**
+     * 테이블 삭제
+     */
+    deleteTable(databaseId: string, tableId: string): Promise<void>;
+    /**
+     * 컬럼 목록 조회
+     */
+    getColumns(tableId: string): Promise<ColumnSchema[]>;
+    /**
+     * 컬럼 생성
+     */
+    createColumn(tableId: string, data: CreateColumnRequest): Promise<ColumnSchema>;
+    /**
+     * 컬럼 수정
+     */
+    updateColumn(tableId: string, columnId: string, data: UpdateColumnRequest): Promise<ColumnSchema>;
+    /**
+     * 컬럼 삭제
+     */
+    deleteColumn(tableId: string, columnId: string): Promise<void>;
+    /**
+     * 데이터 조회 (페이지네이션)
+     */
+    getData(tableId: string, options?: QueryOptions): Promise<FetchDataResponse>;
+    /**
+     * 조건부 데이터 조회 (Where, OrderBy)
+     */
+    queryData(tableId: string, options: QueryOptions): Promise<FetchDataResponse>;
+    /**
+     * 단일 데이터 조회
+     */
+    getDataById(tableId: string, dataId: string): Promise<DataItem>;
+    /**
+     * 데이터 생성
+     */
+    createData(tableId: string, data: CreateDataRequest): Promise<DataItem>;
+    /**
+     * 데이터 수정
+     */
+    updateData(tableId: string, dataId: string, data: UpdateDataRequest): Promise<DataItem>;
+    /**
+     * 데이터 삭제
+     */
+    deleteData(tableId: string, dataId: string): Promise<void>;
+    /**
+     * 여러 데이터 한번에 생성 (Bulk Create)
+     */
+    createMany(tableId: string, items: CreateDataRequest[]): Promise<BulkCreateResponse>;
+    /**
+     * 조건에 맞는 데이터 삭제
+     */
+    deleteWhere(tableId: string, where: WhereCondition): Promise<DeleteWhereResponse>;
+}
+
+interface FileItem {
+    id: string;
+    name: string;
+    path: string;
+    type: 'file' | 'folder';
+    mime_type?: string;
+    size: number;
+    url?: string;
+    parent_id?: string;
+    children?: FileItem[];
+    created_at: string;
+    updated_at: string;
+}
+interface UploadFileResponse {
+    id: string;
+    name: string;
+    path: string;
+    type: string;
+    mime_type: string;
+    size: number;
+    url: string;
+    parent_id?: string;
+    created_at: string;
+}
+interface CreateFolderRequest {
+    name: string;
+    parent_id?: string;
+}
+interface CreateFolderResponse {
+    id: string;
+    name: string;
+    path: string;
+    type: string;
+    parent_id?: string;
+    created_at: string;
+}
+interface MoveFileRequest {
+    new_parent_id?: string;
+}
+interface RenameFileRequest {
+    name: string;
+}
+interface RenameFileResponse {
+    id: string;
+    name: string;
+    path: string;
+}
+interface FetchFilesResponse {
+    files: FileItem[];
+}
+
+declare class StorageAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * API Key 인증 시 /v1/public 접두사 반환
+     */
+    private getPublicPrefix;
+    /**
+     * 파일 목록 조회
+     */
+    getFiles(storageId: string): Promise<FileItem[]>;
+    /**
+     * 파일 업로드
+     */
+    uploadFile(storageId: string, file: File, parentId?: string): Promise<UploadFileResponse>;
+    /**
+     * 여러 파일 업로드
+     */
+    uploadFiles(storageId: string, files: File[], parentId?: string): Promise<UploadFileResponse[]>;
+    /**
+     * 폴더 생성
+     */
+    createFolder(storageId: string, data: CreateFolderRequest): Promise<CreateFolderResponse>;
+    /**
+     * 파일/폴더 삭제
+     */
+    deleteFile(storageId: string, fileId: string): Promise<void>;
+    /**
+     * 파일/폴더 이동
+     */
+    moveFile(storageId: string, fileId: string, data: MoveFileRequest): Promise<void>;
+    /**
+     * 파일/폴더 이름 변경
+     */
+    renameFile(storageId: string, fileId: string, data: RenameFileRequest): Promise<RenameFileResponse>;
+    /**
+     * 파일 URL 가져오기
+     */
+    getFileUrl(file: FileItem): string | null;
+    /**
+     * 이미지 파일 여부 확인
+     */
+    isImageFile(file: FileItem): boolean;
+}
+
+/**
+ * API Key 관련 타입 정의
+ */
+/**
+ * API Key 아이템
+ */
+interface ApiKeyItem {
+    /** API Key ID */
+    id: string;
+    /** API Key 이름 */
+    name: string;
+    /** 키 앞 12자리 (표시용) */
+    key_prefix: string;
+    /** 활성화 상태 */
+    is_active: boolean;
+    /** 마지막 사용 시간 */
+    last_used_at?: string;
+    /** 만료일 (null이면 무제한) */
+    expires_at?: string;
+    /** 생성일 */
+    created_at: string;
+}
+/**
+ * API Key 생성 요청
+ */
+interface CreateApiKeyRequest {
+    /** API Key 이름 (예: Production, Development) */
+    name: string;
+    /** 만료일 (옵션) */
+    expires_at?: string;
+}
+/**
+ * API Key 생성 응답 (전체 키는 이때만 반환됨)
+ */
+interface CreateApiKeyResponse {
+    /** API Key ID */
+    id: string;
+    /** API Key 이름 */
+    name: string;
+    /** 전체 키 값 (생성 시에만 반환, 안전하게 보관 필요) */
+    key: string;
+    /** 키 앞 12자리 (표시용) */
+    key_prefix: string;
+    /** 활성화 상태 */
+    is_active: boolean;
+    /** 만료일 */
+    expires_at?: string;
+    /** 생성일 */
+    created_at: string;
+}
+/**
+ * API Key 목록 조회 응답
+ */
+interface FetchApiKeysResponse {
+    api_keys: ApiKeyItem[];
+}
+/**
+ * API Key 수정 요청
+ */
+interface UpdateApiKeyRequest {
+    /** API Key 이름 변경 */
+    name?: string;
+    /** 활성화/비활성화 */
+    is_active?: boolean;
+}
+/**
+ * API Key 수정 응답
+ */
+interface UpdateApiKeyResponse {
+    id: string;
+    name: string;
+    key_prefix: string;
+    is_active: boolean;
+    expires_at?: string;
+    created_at: string;
+}
+
+/**
+ * API Key 관리 API
+ *
+ * @example
+ * ```typescript
+ * // API Key 목록 조회
+ * const keys = await cb.apiKey.getApiKeys('app-id')
+ *
+ * // 새 API Key 생성
+ * const newKey = await cb.apiKey.createApiKey('app-id', { name: 'Production' })
+ * console.log(newKey.key) // 전체 키 (이때만 볼 수 있음!)
+ *
+ * // API Key 비활성화
+ * await cb.apiKey.updateApiKey('app-id', 'key-id', { is_active: false })
+ *
+ * // API Key 삭제
+ * await cb.apiKey.deleteApiKey('app-id', 'key-id')
+ * ```
+ */
+declare class ApiKeyAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 앱의 API Key 목록을 조회합니다
+     * @param appId 앱 ID
+     */
+    getApiKeys(appId: string): Promise<FetchApiKeysResponse>;
+    /**
+     * 새 API Key를 생성합니다
+     *
+     * **중요**: 반환되는 `key` 값은 이 응답에서만 볼 수 있습니다.
+     * 안전한 곳에 저장하세요.
+     *
+     * @param appId 앱 ID
+     * @param data 생성할 API Key 정보
+     */
+    createApiKey(appId: string, data: CreateApiKeyRequest): Promise<CreateApiKeyResponse>;
+    /**
+     * API Key를 수정합니다 (이름 변경, 활성화/비활성화)
+     * @param appId 앱 ID
+     * @param keyId API Key ID
+     * @param data 수정할 정보
+     */
+    updateApiKey(appId: string, keyId: string, data: UpdateApiKeyRequest): Promise<UpdateApiKeyResponse>;
+    /**
+     * API Key를 삭제합니다
+     * @param appId 앱 ID
+     * @param keyId API Key ID
+     */
+    deleteApiKey(appId: string, keyId: string): Promise<void>;
+}
+
+/**
+ * 함수 실행 요청
+ */
+interface InvokeFunctionRequest {
+    /** 함수에 전달할 데이터 */
+    payload?: Record<string, unknown>;
+    /** 실행 타임아웃 (초) */
+    timeout?: number;
+}
+/**
+ * 함수 실행 응답
+ */
+interface InvokeFunctionResponse {
+    /** 실행 성공 여부 */
+    success: boolean;
+    /** 실행 ID */
+    execution_id: string;
+    /** 함수 실행 결과 */
+    result?: Record<string, unknown>;
+    /** 실행 시간 (밀리초) */
+    duration: number;
+    /** 실행 상태 ('success' | 'error' | 'timeout') */
+    status: 'success' | 'error' | 'timeout';
+    /** 에러 메시지 (실패 시) */
+    error?: string;
+}
+
+declare class FunctionsAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * API Key 인증 시 /v1/public 접두사 반환
+     */
+    private getPublicPrefix;
+    /**
+     * 서버리스 함수 실행
+     *
+     * @param functionId - 함수 ID
+     * @param payload - 함수에 전달할 데이터 (선택)
+     * @param timeout - 실행 타임아웃 (초, 선택)
+     * @returns 함수 실행 결과
+     *
+     * @example
+     * ```typescript
+     * // 기본 실행
+     * const result = await cb.functions.invoke('function-id')
+     *
+     * // 데이터와 함께 실행
+     * const result = await cb.functions.invoke('function-id', {
+     *     name: 'John',
+     *     age: 30
+     * })
+     *
+     * // 타임아웃 설정
+     * const result = await cb.functions.invoke('function-id', { data: 'test' }, 60)
+     * ```
+     */
+    invoke(functionId: string, payload?: Record<string, unknown>, timeout?: number): Promise<InvokeFunctionResponse>;
+    /**
+     * 서버리스 함수 실행 (비동기 래퍼)
+     * 결과만 반환하고 메타데이터는 제외
+     *
+     * @param functionId - 함수 ID
+     * @param payload - 함수에 전달할 데이터 (선택)
+     * @returns 함수 실행 결과 데이터
+     *
+     * @example
+     * ```typescript
+     * const data = await cb.functions.call('function-id', { name: 'John' })
+     * console.log(data) // 함수가 반환한 데이터
+     * ```
+     */
+    call<T = unknown>(functionId: string, payload?: Record<string, unknown>): Promise<T>;
+}
+
+/**
+ * Realtime API 타입 정의
+ */
+/** 구독 옵션 */
+interface SubscribeOptions {
+    /** 히스토리 로드 개수 (persist=true인 카테고리만) */
+    historyLimit?: number;
+}
+/** 카테고리 정보 */
+interface CategoryInfo {
+    category: string;
+    persist: boolean;
+    historyCount: number;
+    readReceipt: boolean;
+}
+/** 메시지 데이터 */
+interface RealtimeMessage<T = unknown> {
+    id?: string;
+    category: string;
+    from?: string;
+    data: T;
+    sentAt: number;
+}
+/** 히스토리 응답 */
+interface HistoryResponse<T = unknown> {
+    category: string;
+    messages: RealtimeMessage<T>[];
+    total: number;
+}
+/** WebSocket 연결 상태 */
+type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
+/** 연결 옵션 */
+interface RealtimeConnectOptions {
+    /** 재연결 시도 횟수 (기본: 5) */
+    maxRetries?: number;
+    /** 재연결 간격 (밀리초, 기본: 1000) */
+    retryInterval?: number;
+    /** 사용자 ID (인증된 사용자) */
+    userId?: string;
+    /** JWT 액세스 토큰 (앱 멤버 인증용, API Key보다 우선) */
+    accessToken?: string;
+}
+/** 이벤트 핸들러 타입 */
+type MessageHandler<T = unknown> = (message: RealtimeMessage<T>) => void;
+type ErrorHandler = (error: Error) => void;
+type StateChangeHandler = (state: ConnectionState) => void;
+/** 메시지 전송 옵션 */
+interface SendOptions {
+    /** true면 발신자도 메시지를 받음 (기본값: true) */
+    includeSelf?: boolean;
+}
+/** 구독 객체 */
+interface Subscription {
+    /** 카테고리 정보 */
+    info: CategoryInfo;
+    /** 메시지 전송 */
+    send<T = unknown>(data: T, options?: SendOptions): Promise<void>;
+    /** 히스토리 조회 (persist=true인 경우만) */
+    getHistory<T = unknown>(limit?: number): Promise<HistoryResponse<T>>;
+    /** 구독 해제 */
+    unsubscribe(): Promise<void>;
+    /** 메시지 수신 핸들러 등록 */
+    onMessage<T = unknown>(handler: MessageHandler<T>): void;
+}
+/** 클라이언트 -> 서버 메시지 */
+interface ClientMessage {
+    category: string;
+    action: 'subscribe' | 'unsubscribe' | 'send' | 'invoke' | 'ping' | 'history';
+    data?: unknown;
+    request_id: string;
+}
+/** 서버 -> 클라이언트 메시지 */
+interface ServerMessage<T = unknown> {
+    category?: string;
+    event: 'connected' | 'subscribed' | 'unsubscribed' | 'message' | 'sent' | 'result' | 'error' | 'pong' | 'history';
+    data?: T;
+    request_id?: string;
+    error?: string;
+    timestamp: number;
+}
+/** 연결 성공 데이터 */
+interface ConnectedData {
+    connection_id: string;
+    app_id: string;
+    client_id: string;
+    user_id?: string;
+}
+/** 구독 성공 데이터 */
+interface SubscribedData {
+    category: string;
+    persist: boolean;
+    history_count: number;
+    read_receipt: boolean;
+}
+
+/**
+ * Realtime API
+ * WebSocket 기반 실시간 통신 API
+ *
+ * @example
+ * ```typescript
+ * // 연결
+ * await client.realtime.connect()
+ *
+ * // 카테고리 구독
+ * const chat = await client.realtime.subscribe('chat-room-1')
+ *
+ * // 메시지 수신
+ * chat.onMessage((msg) => {
+ *     console.log('Received:', msg.data)
+ * })
+ *
+ * // 메시지 전송
+ * await chat.send({ text: 'Hello!' })
+ *
+ * // 히스토리 조회 (persist=true인 카테고리만)
+ * if (chat.info.persist) {
+ *     const history = await chat.getHistory(50)
+ *     console.log('History:', history.messages)
+ * }
+ *
+ * // 구독 해제
+ * await chat.unsubscribe()
+ *
+ * // 연결 해제
+ * client.realtime.disconnect()
+ * ```
+ */
+declare class RealtimeAPI {
+    private http;
+    private socketUrl;
+    private ws;
+    private state;
+    private _connectionId;
+    private clientId;
+    private userId?;
+    private _appId;
+    /** 현재 연결 ID */
+    get connectionId(): string | null;
+    /** 현재 연결된 앱 ID */
+    get appId(): string | null;
+    private options;
+    private retryCount;
+    private pendingRequests;
+    private subscriptions;
+    private stateHandlers;
+    private errorHandlers;
+    constructor(http: HttpClient, socketUrl: string);
+    /**
+     * WebSocket 연결
+     * @param options 연결 옵션
+     * - accessToken: JWT 토큰으로 인증 (앱 멤버용, API Key보다 우선)
+     * - userId: 사용자 식별자 (표시용)
+     */
+    connect(options?: RealtimeConnectOptions): Promise<void>;
+    /**
+     * 연결 해제
+     */
+    disconnect(): void;
+    /**
+     * 카테고리 구독
+     */
+    subscribe(category: string, options?: SubscribeOptions): Promise<Subscription>;
+    /**
+     * 구독 해제
+     */
+    unsubscribe(category: string): Promise<void>;
+    /**
+     * 메시지 전송
+     * @param category 카테고리 이름
+     * @param data 전송할 데이터
+     * @param options 전송 옵션 (includeSelf: 발신자도 메시지 수신 여부, 기본값 true)
+     */
+    sendMessage<T = unknown>(category: string, data: T, options?: SendOptions): Promise<void>;
+    /**
+     * 히스토리 조회
+     */
+    getHistory<T = unknown>(category: string, limit?: number): Promise<HistoryResponse<T>>;
+    /**
+     * 연결 상태
+     */
+    getState(): ConnectionState;
+    /**
+     * 상태 변경 핸들러 등록
+     */
+    onStateChange(handler: StateChangeHandler): () => void;
+    /**
+     * 에러 핸들러 등록
+     */
+    onError(handler: ErrorHandler): () => void;
+    private doConnect;
+    private handleServerMessage;
+    private handleDisconnect;
+    private sendRequest;
+    private notifyStateChange;
+    private notifyError;
+    private generateClientId;
+    private generateRequestId;
+}
+
+/**
+ * WebRTC 타입 정의
+ */
+/** WebRTC 채널 모드 */
+type WebRTCMode = 'broadcast' | 'interactive';
+/** WebRTC 연결 상태 */
+type WebRTCConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'failed';
+/** WebRTC 연결 옵션 */
+interface WebRTCConnectOptions {
+    /** 룸 ID (channel:room 형식 권장) */
+    roomId: string;
+    /** 사용자 ID (선택) */
+    userId?: string;
+    /** 방송자 여부 (broadcast 모드에서 사용) */
+    isBroadcaster?: boolean;
+    /** 로컬 미디어 스트림 */
+    localStream?: MediaStream;
+}
+/** 피어 정보 */
+interface PeerInfo {
+    /** 피어 ID */
+    peer_id: string;
+    /** 사용자 ID */
+    user_id?: string;
+    /** 방송자 여부 */
+    is_broadcaster?: boolean;
+    /** 참가 시간 */
+    joined_at?: string;
+}
+/** 룸 정보 */
+interface RoomInfo {
+    /** 룸 ID */
+    room_id: string;
+    /** 채널 이름 */
+    channel_name: string;
+    /** 채널 타입 (broadcast/interactive) */
+    channel_type: WebRTCMode;
+    /** 참가자 목록 */
+    peers: PeerInfo[];
+}
+/** 시그널링 메시지 타입 */
+type SignalingMessageType = 'join' | 'joined' | 'leave' | 'offer' | 'answer' | 'ice_candidate' | 'peer_joined' | 'peer_left' | 'error';
+/** 시그널링 메시지 */
+interface SignalingMessage {
+    type: SignalingMessageType;
+    room_id?: string;
+    peer_id?: string;
+    target_id?: string;
+    sdp?: string;
+    candidate?: RTCIceCandidateInit;
+    data?: unknown;
+}
+/** ICE 서버 설정 */
+interface ICEServer {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+}
+/** ICE 서버 목록 응답 */
+interface ICEServersResponse {
+    ice_servers: ICEServer[];
+}
+/** 룸 통계 */
+interface RoomStats {
+    room_id: string;
+    peer_count: number;
+    broadcaster_count: number;
+    created_at: string;
+}
+/** 앱 통계 응답 */
+interface AppStatsResponse {
+    total_rooms: number;
+    total_peers: number;
+    rooms: RoomStats[];
+}
+/** 룸 목록 응답 */
+interface RoomsResponse {
+    rooms: RoomStats[];
+}
+/** 참가 요청 */
+interface JoinRoomRequest {
+    room_id: string;
+    user_id?: string;
+    is_broadcaster?: boolean;
+}
+/** 참가 응답 */
+interface JoinRoomResponse {
+    peer_id: string;
+    room_id: string;
+    channel_name: string;
+    channel_type: WebRTCMode;
+    peers: PeerInfo[];
+}
+
+/**
+ * WebRTC API
+ * 실시간 영상/음성 통화 (Pion WebRTC 기반)
+ */
+declare class WebRTCAPI {
+    private http;
+    private webrtcUrl;
+    private ws;
+    private state;
+    private stateListeners;
+    private errorListeners;
+    private peerJoinedListeners;
+    private peerLeftListeners;
+    private remoteStreamListeners;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectTimeout;
+    private currentRoomId;
+    private currentPeerId;
+    private currentUserId;
+    private isBroadcaster;
+    private localStream;
+    private channelType;
+    private peerConnections;
+    private remoteStreams;
+    private iceServers;
+    constructor(http: HttpClient, webrtcUrl: string);
+    /**
+     * ICE 서버 목록 조회
+     */
+    getICEServers(): Promise<ICEServer[]>;
+    /**
+     * WebRTC 시그널링 서버에 연결
+     *
+     * @example
+     * ```typescript
+     * // 로컬 스트림 가져오기
+     * const localStream = await navigator.mediaDevices.getUserMedia({
+     *     video: true,
+     *     audio: true
+     * })
+     *
+     * // WebRTC 연결
+     * await cb.webrtc.connect({
+     *     roomId: 'live:room-123',
+     *     userId: 'user-456',
+     *     isBroadcaster: true,
+     *     localStream
+     * })
+     * ```
+     */
+    connect(options: WebRTCConnectOptions): Promise<void>;
+    private connectWebSocket;
+    private buildWebSocketUrl;
+    private handleSignalingMessage;
+    private createPeerConnection;
+    private handleOffer;
+    private handleAnswer;
+    private handleICECandidate;
+    private closePeerConnection;
+    private sendSignaling;
+    private handleDisconnect;
+    private attemptReconnect;
+    /**
+     * WebRTC 연결 해제
+     */
+    disconnect(): void;
+    /**
+     * 현재 연결 상태 조회
+     */
+    getState(): WebRTCConnectionState;
+    /**
+     * 현재 룸 ID 조회
+     */
+    getRoomId(): string | null;
+    /**
+     * 현재 피어 ID 조회
+     */
+    getPeerId(): string | null;
+    /**
+     * 현재 채널 타입 조회
+     */
+    getChannelType(): WebRTCMode;
+    /**
+     * 원격 스트림 조회
+     */
+    getRemoteStream(peerId: string): MediaStream | undefined;
+    /**
+     * 모든 원격 스트림 조회
+     */
+    getAllRemoteStreams(): Map<string, MediaStream>;
+    /**
+     * 로컬 스트림 교체
+     */
+    replaceLocalStream(newStream: MediaStream): void;
+    /**
+     * 오디오 음소거/해제
+     */
+    setAudioEnabled(enabled: boolean): void;
+    /**
+     * 비디오 켜기/끄기
+     */
+    setVideoEnabled(enabled: boolean): void;
+    /**
+     * 연결 상태 변경 이벤트
+     */
+    onStateChange(callback: (state: WebRTCConnectionState) => void): () => void;
+    /**
+     * 에러 이벤트
+     */
+    onError(callback: (error: Error) => void): () => void;
+    /**
+     * 피어 참가 이벤트
+     */
+    onPeerJoined(callback: (peerId: string, info: PeerInfo) => void): () => void;
+    /**
+     * 피어 퇴장 이벤트
+     */
+    onPeerLeft(callback: (peerId: string) => void): () => void;
+    /**
+     * 원격 스트림 수신 이벤트
+     */
+    onRemoteStream(callback: (peerId: string, stream: MediaStream) => void): () => void;
+    private setState;
+    private emitError;
+    private emitPeerJoined;
+    private emitPeerLeft;
+    private emitRemoteStream;
+    /**
+     * 앱의 WebRTC 통계 조회
+     */
+    getStats(appID: string): Promise<AppStatsResponse>;
+    /**
+     * 앱의 활성 룸 목록 조회
+     */
+    getRooms(appID: string): Promise<RoomsResponse>;
+}
+
+type ErrorType = 'error' | 'unhandledrejection' | 'resource' | 'network' | 'custom';
+interface ErrorReport {
+    message: string;
+    source?: string;
+    lineno?: number;
+    colno?: number;
+    stack?: string;
+    error_type?: ErrorType;
+    url?: string;
+    referrer?: string;
+}
+interface ErrorTrackerConfig {
+    /**
+     * 에러 자동 캡처 활성화 여부
+     * @default true
+     */
+    autoCapture?: boolean;
+    /**
+     * 캡처할 에러 타입
+     * @default ['error', 'unhandledrejection']
+     */
+    captureTypes?: ErrorType[];
+    /**
+     * 에러 배치 전송 간격 (ms)
+     * @default 5000
+     */
+    batchInterval?: number;
+    /**
+     * 최대 배치 크기
+     * @default 10
+     */
+    maxBatchSize?: number;
+    /**
+     * 에러 필터 함수 (false 반환 시 무시)
+     */
+    beforeSend?: (error: ErrorReport) => ErrorReport | false | null;
+    /**
+     * 디버그 모드 (콘솔 로깅)
+     * @default false
+     */
+    debug?: boolean;
+}
+/**
+ * 에러 트래커 API
+ * 클라이언트 JavaScript 에러를 서버로 리포트합니다.
+ */
+declare class ErrorTrackerAPI {
+    private http;
+    private storageWebId;
+    private config;
+    private errorQueue;
+    private batchTimer;
+    private isInitialized;
+    private originalOnError;
+    private originalOnUnhandledRejection;
+    constructor(http: HttpClient, config?: ErrorTrackerConfig);
+    /**
+     * 에러 트래커 초기화
+     * @param storageWebId 웹 스토리지 ID
+     */
+    init(storageWebId: string): void;
+    /**
+     * 에러 트래커 정리 (언마운트 시 호출)
+     */
+    destroy(): void;
+    /**
+     * 수동으로 에러 리포트
+     */
+    captureError(error: Error | string, extra?: Partial<ErrorReport>): Promise<void>;
+    /**
+     * 커스텀 에러 리포트
+     */
+    captureMessage(message: string, extra?: Partial<ErrorReport>): Promise<void>;
+    /**
+     * 큐에 있는 에러들 즉시 전송
+     */
+    flush(): Promise<void>;
+    private log;
+    private setupAutoCapture;
+    private removeAutoCapture;
+    private handleGlobalError;
+    private handleUnhandledRejection;
+    private createErrorReport;
+    private queueError;
+    private startBatchTimer;
+    private stopBatchTimer;
+    private flushQueue;
+}
+
+/**
+ * OAuth 프로바이더 타입
+ */
+type OAuthProvider = 'google' | 'naver' | 'github' | 'discord';
+/**
+ * 활성화된 OAuth 프로바이더 정보
+ */
+interface EnabledProviderInfo {
+    provider: OAuthProvider;
+    client_id: string;
+}
+/**
+ * 활성화된 프로바이더 목록 응답
+ */
+interface EnabledProvidersResponse {
+    providers: EnabledProviderInfo[];
+}
+/**
+ * OAuth 인증 URL 요청
+ */
+interface GetAuthorizationURLRequest {
+    redirect_uri: string;
+    state?: string;
+}
+/**
+ * OAuth 인증 URL 응답
+ */
+interface GetAuthorizationURLResponse {
+    authorization_url: string;
+}
+/**
+ * OAuth 콜백 요청
+ */
+interface OAuthCallbackRequest {
+    code: string;
+    redirect_uri: string;
+}
+/**
+ * OAuth 콜백 응답
+ */
+interface OAuthCallbackResponse {
+    member_id: string;
+    access_token: string;
+    refresh_token: string;
+    is_new_member: boolean;
+}
+
+/**
+ * OAuth API
+ * 소셜 로그인 (Google, Naver, GitHub, Discord)
+ */
+declare class OAuthAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * 활성화된 OAuth 프로바이더 목록 조회
+     * 콘솔에서 설정된 소셜 로그인 프로바이더 목록을 반환합니다.
+     *
+     * @example
+     * ```typescript
+     * const { providers } = await cb.oauth.getEnabledProviders()
+     * // [{ provider: 'google', client_id: '...' }, { provider: 'kakao', client_id: '...' }]
+     * ```
+     */
+    getEnabledProviders(): Promise<EnabledProvidersResponse>;
+    /**
+     * OAuth 인증 URL 조회
+     * 사용자를 소셜 로그인 페이지로 리다이렉트할 URL을 반환합니다.
+     *
+     * @param provider - OAuth 프로바이더 (google, naver, github, discord)
+     * @param options - redirect_uri와 선택적 state 파라미터
+     * @returns 인증 URL
+     *
+     * @example
+     * ```typescript
+     * const { authorization_url } = await cb.oauth.getAuthorizationURL('google', {
+     *     redirect_uri: 'https://myapp.com/auth/callback'
+     * })
+     *
+     * // 사용자를 OAuth 페이지로 리다이렉트
+     * window.location.href = authorization_url
+     * ```
+     */
+    getAuthorizationURL(provider: OAuthProvider, options: GetAuthorizationURLRequest): Promise<GetAuthorizationURLResponse>;
+    /**
+     * OAuth 콜백 처리
+     * 소셜 로그인 후 콜백으로 받은 code를 사용하여 로그인을 완료합니다.
+     * 성공 시 자동으로 토큰이 저장됩니다.
+     *
+     * @param provider - OAuth 프로바이더
+     * @param data - code와 redirect_uri
+     * @returns 로그인 결과 (member_id, 토큰, 신규 회원 여부)
+     *
+     * @example
+     * ```typescript
+     * // 콜백 페이지에서 URL 파라미터로 code 추출
+     * const urlParams = new URLSearchParams(window.location.search)
+     * const code = urlParams.get('code')
+     *
+     * const result = await cb.oauth.handleCallback('google', {
+     *     code: code,
+     *     redirect_uri: 'https://myapp.com/auth/callback'
+     * })
+     *
+     * if (result.is_new_member) {
+     *     console.log('신규 회원입니다!')
+     * }
+     * ```
+     */
+    handleCallback(provider: OAuthProvider, data: OAuthCallbackRequest): Promise<OAuthCallbackResponse>;
+    /**
+     * 소셜 로그인 전체 플로우 (팝업 방식)
+     * 새 창에서 소셜 로그인을 처리하고 결과를 Promise로 반환합니다.
+     *
+     * @param provider - OAuth 프로바이더
+     * @param redirectUri - 콜백 URL (이 페이지에서 postMessage로 결과 전달 필요)
+     * @returns 로그인 결과
+     *
+     * @example
+     * ```typescript
+     * // 로그인 버튼 클릭 시
+     * const result = await cb.oauth.signInWithPopup('google', 'https://myapp.com/auth/popup-callback')
+     * console.log('로그인 성공:', result.member_id)
+     * ```
+     *
+     * @example
+     * ```html
+     * <!-- popup-callback.html -->
+     * <script>
+     *   const urlParams = new URLSearchParams(window.location.search)
+     *   const code = urlParams.get('code')
+     *   const error = urlParams.get('error')
+     *
+     *   window.opener.postMessage({
+     *     type: 'oauth-callback',
+     *     code,
+     *     error
+     *   }, '*')
+     *   window.close()
+     * </script>
+     * ```
+     */
+    signInWithPopup(provider: OAuthProvider, redirectUri: string): Promise<OAuthCallbackResponse>;
+    /**
+     * 소셜 로그인 (리다이렉트 방식)
+     * 현재 페이지를 소셜 로그인 페이지로 리다이렉트합니다.
+     * 콜백 URL에서 handleCallback()을 호출하여 로그인을 완료해야 합니다.
+     *
+     * @param provider - OAuth 프로바이더
+     * @param redirectUri - 콜백 URL
+     *
+     * @example
+     * ```typescript
+     * // 로그인 버튼 클릭 시
+     * await cb.oauth.signInWithRedirect('google', 'https://myapp.com/auth/callback')
+     * // 페이지가 Google 로그인으로 리다이렉트됨
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // callback 페이지에서
+     * const urlParams = new URLSearchParams(window.location.search)
+     * const code = urlParams.get('code')
+     *
+     * if (code) {
+     *     const result = await cb.oauth.handleCallback('google', {
+     *         code,
+     *         redirect_uri: 'https://myapp.com/auth/callback'
+     *     })
+     *     // 로그인 완료, 메인 페이지로 이동
+     *     window.location.href = '/'
+     * }
+     * ```
+     */
+    signInWithRedirect(provider: OAuthProvider, redirectUri: string): Promise<void>;
+}
+
+type PaymentStatus = 'pending' | 'ready' | 'in_progress' | 'done' | 'canceled' | 'partial_canceled' | 'aborted' | 'expired' | 'failed';
+interface PreparePaymentRequest {
+    amount: number;
+    order_name: string;
+    order_id?: string;
+    customer_email?: string;
+    customer_name?: string;
+    customer_phone?: string;
+    metadata?: Record<string, unknown>;
+}
+interface PreparePaymentResponse {
+    payment_id: string;
+    order_id: string;
+    amount: number;
+    order_name: string;
+    customer_key: string;
+    toss_client_key: string;
+    success_url: string;
+    fail_url: string;
+}
+interface ConfirmPaymentRequest {
+    payment_key: string;
+    order_id: string;
+    amount: number;
+}
+interface ConfirmPaymentResponse {
+    payment_id: string;
+    order_id: string;
+    amount: number;
+    status: PaymentStatus;
+    method: string;
+    receipt_url?: string;
+    approved_at?: string;
+}
+interface CancelPaymentRequest {
+    cancel_reason: string;
+    cancel_amount?: number;
+}
+interface CancelPaymentResponse {
+    payment_id: string;
+    order_id: string;
+    original_amount: number;
+    canceled_amount: number;
+    status: PaymentStatus;
+    canceled_at?: string;
+}
+interface PaymentDetail {
+    payment_id: string;
+    order_id: string;
+    order_name: string;
+    amount: number;
+    currency: string;
+    status: PaymentStatus;
+    method?: string;
+    customer_id?: string;
+    customer_email?: string;
+    customer_name?: string;
+    receipt_url?: string;
+    approved_at?: string;
+    canceled_at?: string;
+    canceled_amount?: number;
+    cancel_reason?: string;
+    failure_code?: string;
+    failure_message?: string;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+
+declare class PaymentAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * API Key 인증 시 /v1/public 접두사 반환
+     */
+    private getPublicPrefix;
+    /**
+     * 결제 준비
+     * 토스 결제 위젯에 필요한 정보를 반환합니다.
+     *
+     * @param data - 결제 준비 정보 (금액, 상품명, 고객 정보 등)
+     * @returns 토스 클라이언트 키, 고객 키, 성공/실패 URL 등
+     *
+     * @example
+     * ```typescript
+     * const prepareResult = await client.payment.prepare({
+     *     amount: 10000,
+     *     order_name: '테스트 상품',
+     *     customer_email: 'test@example.com',
+     *     customer_name: '홍길동'
+     * })
+     *
+     * // 토스 결제 위젯 초기화
+     * const tossPayments = TossPayments(prepareResult.toss_client_key)
+     * await tossPayments.requestPayment('카드', {
+     *     amount: prepareResult.amount,
+     *     orderId: prepareResult.order_id,
+     *     orderName: prepareResult.order_name,
+     *     customerKey: prepareResult.customer_key,
+     *     successUrl: prepareResult.success_url,
+     *     failUrl: prepareResult.fail_url
+     * })
+     * ```
+     */
+    prepare(data: PreparePaymentRequest): Promise<PreparePaymentResponse>;
+    /**
+     * 결제 승인
+     * 토스에서 결제 완료 후 콜백으로 받은 정보로 결제를 최종 승인합니다.
+     *
+     * @param data - 결제 승인 정보 (paymentKey, orderId, amount)
+     * @returns 승인된 결제 정보
+     *
+     * @example
+     * ```typescript
+     * // 토스 결제 성공 콜백에서 호출
+     * const result = await client.payment.confirm({
+     *     payment_key: 'tgen_20230101000000...',
+     *     order_id: 'order_123',
+     *     amount: 10000
+     * })
+     *
+     * if (result.status === 'done') {
+     *     console.log('결제 완료!')
+     * }
+     * ```
+     */
+    confirm(data: ConfirmPaymentRequest): Promise<ConfirmPaymentResponse>;
+    /**
+     * 결제 취소
+     * 완료된 결제를 취소합니다. 부분 취소도 가능합니다.
+     *
+     * @param paymentId - 결제 ID (Connect Base에서 발급한 ID)
+     * @param data - 취소 정보 (사유, 부분 취소 금액)
+     * @returns 취소된 결제 정보
+     *
+     * @example
+     * ```typescript
+     * // 전액 취소
+     * const result = await client.payment.cancel(paymentId, {
+     *     cancel_reason: '고객 요청'
+     * })
+     *
+     * // 부분 취소
+     * const result = await client.payment.cancel(paymentId, {
+     *     cancel_reason: '부분 환불',
+     *     cancel_amount: 5000
+     * })
+     * ```
+     */
+    cancel(paymentId: string, data: CancelPaymentRequest): Promise<CancelPaymentResponse>;
+    /**
+     * 주문 ID로 결제 조회
+     * 특정 주문의 결제 상태를 조회합니다.
+     *
+     * @param orderId - 주문 ID
+     * @returns 결제 상세 정보
+     *
+     * @example
+     * ```typescript
+     * const payment = await client.payment.getByOrderId('order_123')
+     * console.log(`결제 상태: ${payment.status}`)
+     * console.log(`결제 금액: ${payment.amount}원`)
+     * ```
+     */
+    getByOrderId(orderId: string): Promise<PaymentDetail>;
+}
+
+interface IssueBillingKeyRequest {
+    /** 토스 인증 키 (카드 등록 후 받은 키) */
+    auth_key: string;
+    /** 고객 이메일 */
+    customer_email?: string;
+    /** 고객 이름 */
+    customer_name?: string;
+    /** 고객 전화번호 */
+    customer_phone?: string;
+    /** 기본 결제 수단으로 설정 */
+    is_default?: boolean;
+}
+interface IssueBillingKeyResponse {
+    /** 빌링키 등록을 위한 URL */
+    auth_url: string;
+    /** 고객 키 (토스에서 사용) */
+    customer_key: string;
+    /** 토스 클라이언트 키 */
+    toss_client_key: string;
+}
+interface ConfirmBillingKeyRequest {
+    /** 고객 키 */
+    customer_key: string;
+    /** 토스 인증 키 */
+    auth_key: string;
+    /** 고객 이메일 */
+    customer_email?: string;
+    /** 고객 이름 */
+    customer_name?: string;
+    /** 고객 전화번호 */
+    customer_phone?: string;
+    /** 기본 결제 수단으로 설정 */
+    is_default?: boolean;
+}
+interface BillingKeyResponse {
+    /** 빌링키 ID */
+    id: string;
+    /** 고객 키 */
+    customer_key: string;
+    /** 카드사 */
+    card_company: string;
+    /** 마스킹된 카드 번호 */
+    card_number: string;
+    /** 카드 타입 (신용/체크) */
+    card_type: string;
+    /** 카드 별명 */
+    card_nickname: string;
+    /** 기본 결제 수단 여부 */
+    is_default: boolean;
+    /** 활성 여부 */
+    is_active: boolean;
+    /** 고객 이메일 */
+    customer_email: string;
+    /** 고객 이름 */
+    customer_name: string;
+    /** 인증 일시 */
+    authenticated_at: string;
+    /** 생성 일시 */
+    created_at: string;
+}
+interface UpdateBillingKeyRequest {
+    /** 카드 별명 */
+    card_nickname?: string;
+    /** 기본 결제 수단 여부 */
+    is_default?: boolean;
+}
+interface ListBillingKeysResponse {
+    billing_keys: BillingKeyResponse[];
+}
+type BillingCycle = 'daily' | 'weekly' | 'monthly' | 'yearly';
+type SubscriptionStatus = 'active' | 'paused' | 'canceled' | 'past_due' | 'expired' | 'trial';
+interface CreateSubscriptionRequest {
+    /** 빌링키 ID */
+    billing_key_id: string;
+    /** 플랜 이름 */
+    plan_name: string;
+    /** 플랜 설명 */
+    plan_description?: string;
+    /** 결제 금액 */
+    amount: number;
+    /** 통화 (기본: KRW) */
+    currency?: string;
+    /** 결제 주기 */
+    billing_cycle: BillingCycle;
+    /** 결제일 (monthly: 1-28일, weekly: 0-6 요일) */
+    billing_day?: number;
+    /** 트라이얼 기간 (일) */
+    trial_days?: number;
+    /** 고객 이메일 */
+    customer_email?: string;
+    /** 고객 이름 */
+    customer_name?: string;
+    /** 메타데이터 */
+    metadata?: Record<string, unknown>;
+}
+interface SubscriptionResponse {
+    /** 구독 ID (UUID) */
+    id: string;
+    /** 구독 ID (문자열) */
+    subscription_id: string;
+    /** 플랜 이름 */
+    plan_name: string;
+    /** 플랜 설명 */
+    plan_description: string;
+    /** 결제 금액 */
+    amount: number;
+    /** 통화 */
+    currency: string;
+    /** 결제 주기 */
+    billing_cycle: BillingCycle;
+    /** 결제일 */
+    billing_day: number;
+    /** 구독 상태 */
+    status: SubscriptionStatus;
+    /** 구독 시작일 */
+    started_at: string;
+    /** 현재 기간 시작일 */
+    current_period_start: string;
+    /** 현재 기간 종료일 */
+    current_period_end: string;
+    /** 다음 결제일 */
+    next_billing_at: string | null;
+    /** 취소일 */
+    canceled_at: string | null;
+    /** 종료일 */
+    ended_at: string | null;
+    /** 트라이얼 종료일 */
+    trial_end_at: string | null;
+    /** 총 결제 금액 */
+    total_paid: number;
+    /** 결제 횟수 */
+    payment_count: number;
+    /** 고객 이메일 */
+    customer_email: string;
+    /** 고객 이름 */
+    customer_name: string;
+    /** 메타데이터 */
+    metadata: Record<string, unknown> | null;
+    /** 빌링키 정보 */
+    billing_key?: BillingKeyResponse;
+    /** 생성 일시 */
+    created_at: string;
+    /** 수정 일시 */
+    updated_at: string;
+}
+interface UpdateSubscriptionRequest {
+    /** 새 빌링키 ID */
+    billing_key_id?: string;
+    /** 플랜 이름 */
+    plan_name?: string;
+    /** 플랜 설명 */
+    plan_description?: string;
+    /** 결제 금액 */
+    amount?: number;
+    /** 메타데이터 */
+    metadata?: Record<string, unknown>;
+}
+interface PauseSubscriptionRequest {
+    /** 일시정지 사유 */
+    reason?: string;
+}
+interface CancelSubscriptionRequest {
+    /** 취소 사유 */
+    reason?: string;
+    /** 즉시 취소 여부 (false면 현재 기간 종료 후 취소) */
+    immediate?: boolean;
+}
+interface ListSubscriptionsRequest {
+    /** 상태 필터 */
+    status?: SubscriptionStatus;
+    /** 페이지 크기 */
+    limit?: number;
+    /** 오프셋 */
+    offset?: number;
+}
+interface ListSubscriptionsResponse {
+    subscriptions: SubscriptionResponse[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+type SubscriptionPaymentStatus = 'pending' | 'done' | 'failed' | 'canceled';
+interface SubscriptionPaymentResponse {
+    /** 결제 ID */
+    id: string;
+    /** 구독 ID */
+    subscription_id: string;
+    /** 토스 결제 키 */
+    payment_key: string;
+    /** 주문 ID */
+    order_id: string;
+    /** 결제 금액 */
+    amount: number;
+    /** 통화 */
+    currency: string;
+    /** 결제 상태 */
+    status: SubscriptionPaymentStatus;
+    /** 기간 시작일 */
+    period_start: string;
+    /** 기간 종료일 */
+    period_end: string;
+    /** 결제 일시 */
+    paid_at: string | null;
+    /** 영수증 URL */
+    receipt_url: string;
+    /** 실패 코드 */
+    failure_code: string;
+    /** 실패 메시지 */
+    failure_message: string;
+    /** 재시도 횟수 */
+    retry_count: number;
+    /** 카드사 */
+    card_company: string;
+    /** 카드 번호 */
+    card_number: string;
+    /** 생성 일시 */
+    created_at: string;
+}
+interface ListSubscriptionPaymentsRequest {
+    /** 상태 필터 */
+    status?: SubscriptionPaymentStatus;
+    /** 페이지 크기 */
+    limit?: number;
+    /** 오프셋 */
+    offset?: number;
+}
+interface ListSubscriptionPaymentsResponse {
+    payments: SubscriptionPaymentResponse[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface ChargeWithBillingKeyRequest {
+    /** 빌링키 ID */
+    billing_key_id: string;
+    /** 결제 금액 */
+    amount: number;
+    /** 상품명 */
+    order_name: string;
+    /** 주문 ID (선택) */
+    order_id?: string;
+    /** 고객 이메일 */
+    customer_email?: string;
+    /** 고객 이름 */
+    customer_name?: string;
+    /** 메타데이터 */
+    metadata?: Record<string, unknown>;
+}
+interface ChargeWithBillingKeyResponse {
+    /** 토스 결제 키 */
+    payment_key: string;
+    /** 주문 ID */
+    order_id: string;
+    /** 결제 금액 */
+    amount: number;
+    /** 결제 상태 */
+    status: string;
+    /** 영수증 URL */
+    receipt_url: string;
+    /** 승인 일시 */
+    approved_at: string | null;
+    /** 카드사 */
+    card_company: string;
+    /** 카드 번호 */
+    card_number: string;
+}
+
+declare class SubscriptionAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * API Key 인증 시 /v1/public 접두사 반환
+     */
+    private getPublicPrefix;
+    /**
+     * 빌링키 발급 시작
+     * 토스 카드 등록 위젯에 필요한 정보를 반환합니다.
+     *
+     * @returns 토스 클라이언트 키, 고객 키 등
+     *
+     * @example
+     * ```typescript
+     * const result = await client.subscription.issueBillingKey()
+     *
+     * // 토스 카드 등록 위젯
+     * const tossPayments = TossPayments(result.toss_client_key)
+     * await tossPayments.requestBillingAuth('카드', {
+     *     customerKey: result.customer_key,
+     *     successUrl: 'https://mysite.com/billing/success',
+     *     failUrl: 'https://mysite.com/billing/fail'
+     * })
+     * ```
+     */
+    issueBillingKey(): Promise<IssueBillingKeyResponse>;
+    /**
+     * 빌링키 등록 확인
+     * 토스에서 카드 등록 완료 후 빌링키를 확정합니다.
+     *
+     * @param data - 등록 확인 정보
+     * @returns 등록된 빌링키 정보
+     *
+     * @example
+     * ```typescript
+     * const billingKey = await client.subscription.confirmBillingKey({
+     *     customer_key: 'cust_xxxxx',
+     *     auth_key: 'auth_xxxxx',
+     *     customer_email: 'test@example.com',
+     *     customer_name: '홍길동',
+     *     is_default: true
+     * })
+     * ```
+     */
+    confirmBillingKey(data: ConfirmBillingKeyRequest): Promise<BillingKeyResponse>;
+    /**
+     * 빌링키 목록 조회
+     *
+     * @param customerId - 특정 고객의 빌링키만 조회 (선택)
+     * @returns 빌링키 목록
+     *
+     * @example
+     * ```typescript
+     * const { billing_keys } = await client.subscription.listBillingKeys()
+     * console.log(`등록된 카드: ${billing_keys.length}개`)
+     * ```
+     */
+    listBillingKeys(customerId?: string): Promise<ListBillingKeysResponse>;
+    /**
+     * 빌링키 상세 조회
+     *
+     * @param billingKeyId - 빌링키 ID
+     * @returns 빌링키 상세 정보
+     */
+    getBillingKey(billingKeyId: string): Promise<BillingKeyResponse>;
+    /**
+     * 빌링키 수정
+     *
+     * @param billingKeyId - 빌링키 ID
+     * @param data - 수정 정보
+     * @returns 수정된 빌링키 정보
+     *
+     * @example
+     * ```typescript
+     * await client.subscription.updateBillingKey(billingKeyId, {
+     *     card_nickname: '주 결제 카드',
+     *     is_default: true
+     * })
+     * ```
+     */
+    updateBillingKey(billingKeyId: string, data: UpdateBillingKeyRequest): Promise<BillingKeyResponse>;
+    /**
+     * 빌링키 삭제
+     *
+     * @param billingKeyId - 빌링키 ID
+     */
+    deleteBillingKey(billingKeyId: string): Promise<void>;
+    /**
+     * 구독 생성
+     * 정기결제 구독을 생성합니다.
+     *
+     * @param data - 구독 정보
+     * @returns 생성된 구독 정보
+     *
+     * @example
+     * ```typescript
+     * const subscription = await client.subscription.create({
+     *     billing_key_id: 'bk_xxxxx',
+     *     plan_name: '프리미엄 플랜',
+     *     amount: 9900,
+     *     billing_cycle: 'monthly',
+     *     billing_day: 15,  // 매월 15일 결제
+     *     trial_days: 7     // 7일 무료 체험
+     * })
+     * ```
+     */
+    create(data: CreateSubscriptionRequest): Promise<SubscriptionResponse>;
+    /**
+     * 구독 목록 조회
+     *
+     * @param params - 조회 옵션
+     * @returns 구독 목록
+     *
+     * @example
+     * ```typescript
+     * const { subscriptions, total } = await client.subscription.list({
+     *     status: 'active',
+     *     limit: 10
+     * })
+     * ```
+     */
+    list(params?: ListSubscriptionsRequest): Promise<ListSubscriptionsResponse>;
+    /**
+     * 구독 상세 조회
+     *
+     * @param subscriptionId - 구독 ID
+     * @returns 구독 상세 정보
+     */
+    get(subscriptionId: string): Promise<SubscriptionResponse>;
+    /**
+     * 구독 수정
+     *
+     * @param subscriptionId - 구독 ID
+     * @param data - 수정 정보
+     * @returns 수정된 구독 정보
+     *
+     * @example
+     * ```typescript
+     * await client.subscription.update(subscriptionId, {
+     *     plan_name: '엔터프라이즈 플랜',
+     *     amount: 29900
+     * })
+     * ```
+     */
+    update(subscriptionId: string, data: UpdateSubscriptionRequest): Promise<SubscriptionResponse>;
+    /**
+     * 구독 일시정지
+     *
+     * @param subscriptionId - 구독 ID
+     * @param data - 일시정지 정보
+     * @returns 일시정지된 구독 정보
+     *
+     * @example
+     * ```typescript
+     * await client.subscription.pause(subscriptionId, {
+     *     reason: '고객 요청'
+     * })
+     * ```
+     */
+    pause(subscriptionId: string, data?: PauseSubscriptionRequest): Promise<SubscriptionResponse>;
+    /**
+     * 구독 재개
+     *
+     * @param subscriptionId - 구독 ID
+     * @returns 재개된 구독 정보
+     *
+     * @example
+     * ```typescript
+     * await client.subscription.resume(subscriptionId)
+     * ```
+     */
+    resume(subscriptionId: string): Promise<SubscriptionResponse>;
+    /**
+     * 구독 취소
+     *
+     * @param subscriptionId - 구독 ID
+     * @param data - 취소 정보
+     * @returns 취소된 구독 정보
+     *
+     * @example
+     * ```typescript
+     * // 현재 기간 종료 후 취소
+     * await client.subscription.cancel(subscriptionId, {
+     *     reason: '서비스 불만족'
+     * })
+     *
+     * // 즉시 취소
+     * await client.subscription.cancel(subscriptionId, {
+     *     reason: '즉시 해지 요청',
+     *     immediate: true
+     * })
+     * ```
+     */
+    cancel(subscriptionId: string, data: CancelSubscriptionRequest): Promise<SubscriptionResponse>;
+    /**
+     * 구독 결제 이력 조회
+     *
+     * @param subscriptionId - 구독 ID
+     * @param params - 조회 옵션
+     * @returns 결제 이력 목록
+     *
+     * @example
+     * ```typescript
+     * const { payments } = await client.subscription.listPayments(subscriptionId, {
+     *     limit: 10
+     * })
+     * ```
+     */
+    listPayments(subscriptionId: string, params?: ListSubscriptionPaymentsRequest): Promise<ListSubscriptionPaymentsResponse>;
+    /**
+     * 빌링키로 즉시 결제
+     * 구독 없이 빌링키로 일회성 결제를 진행합니다.
+     *
+     * @param data - 결제 정보
+     * @returns 결제 결과
+     *
+     * @example
+     * ```typescript
+     * const result = await client.subscription.chargeWithBillingKey({
+     *     billing_key_id: 'bk_xxxxx',
+     *     amount: 15000,
+     *     order_name: '추가 결제'
+     * })
+     *
+     * if (result.status === 'DONE') {
+     *     console.log('결제 완료!')
+     * }
+     * ```
+     */
+    chargeWithBillingKey(data: ChargeWithBillingKeyRequest): Promise<ChargeWithBillingKeyResponse>;
+}
+
+/**
+ * Push Notification Types
+ */
+type PushPlatform = 'ios' | 'android' | 'web';
+interface RegisterDeviceRequest {
+    /** 디바이스 토큰 (APNS/FCM/Web Push) */
+    device_token: string;
+    /** 플랫폼 */
+    platform: PushPlatform;
+    /** 디바이스 고유 ID (optional) */
+    device_id?: string;
+    /** 디바이스 이름 (예: "iPhone 15 Pro") */
+    device_name?: string;
+    /** 디바이스 모델 (예: "iPhone15,2") */
+    device_model?: string;
+    /** OS 버전 (예: "17.0") */
+    os_version?: string;
+    /** 앱 버전 (예: "1.0.0") */
+    app_version?: string;
+    /** 언어 코드 (예: "ko") */
+    language?: string;
+    /** 타임존 (예: "Asia/Seoul") */
+    timezone?: string;
+}
+interface DeviceInfo {
+    id: string;
+    device_token: string;
+    platform: PushPlatform;
+    device_id?: string;
+    device_name?: string;
+    device_model?: string;
+    os_version?: string;
+    app_version?: string;
+    language?: string;
+    timezone?: string;
+    is_active: boolean;
+    last_active_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface SubscribeTopicRequest {
+    /** 토픽 이름 */
+    topic_name: string;
+}
+interface VAPIDPublicKeyResponse {
+    public_key: string;
+}
+interface WebPushSubscription {
+    endpoint: string;
+    expirationTime?: number | null;
+    keys: {
+        p256dh: string;
+        auth: string;
+    };
+}
+
+/**
+ * 푸시 알림 API
+ *
+ * @example
+ * ```typescript
+ * // 디바이스 등록 (모바일 앱)
+ * const device = await cb.push.registerDevice({
+ *     device_token: 'fcm-token-here',
+ *     platform: 'android',
+ *     device_name: 'Galaxy S24',
+ * })
+ *
+ * // 토픽 구독
+ * await cb.push.subscribeTopic('announcements')
+ *
+ * // Web Push 등록 (브라우저)
+ * const vapidKey = await cb.push.getVAPIDPublicKey()
+ * const subscription = await registration.pushManager.subscribe({
+ *     userVisibleOnly: true,
+ *     applicationServerKey: vapidKey.public_key
+ * })
+ * await cb.push.registerWebPush(subscription)
+ * ```
+ */
+declare class PushAPI {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * API Key 인증 시 /v1/public 접두사 반환
+     */
+    private getPublicPrefix;
+    /**
+     * 디바이스 등록 (APNS/FCM 토큰)
+     *
+     * @param request 디바이스 등록 정보
+     * @returns 등록된 디바이스 정보
+     *
+     * @example
+     * ```typescript
+     * // iOS 디바이스 등록
+     * const device = await cb.push.registerDevice({
+     *     device_token: 'apns-token-here',
+     *     platform: 'ios',
+     *     device_name: 'iPhone 15 Pro',
+     *     device_model: 'iPhone15,2',
+     *     os_version: '17.0',
+     *     app_version: '1.0.0',
+     * })
+     *
+     * // Android 디바이스 등록
+     * const device = await cb.push.registerDevice({
+     *     device_token: 'fcm-token-here',
+     *     platform: 'android',
+     *     device_name: 'Galaxy S24',
+     * })
+     * ```
+     */
+    registerDevice(request: RegisterDeviceRequest): Promise<DeviceInfo>;
+    /**
+     * 디바이스 등록 해제
+     *
+     * @param deviceId 디바이스 ID
+     *
+     * @example
+     * ```typescript
+     * await cb.push.unregisterDevice('device-id-here')
+     * ```
+     */
+    unregisterDevice(deviceId: string): Promise<void>;
+    /**
+     * 현재 등록된 디바이스 목록 조회
+     *
+     * @returns 디바이스 목록
+     */
+    getDevices(): Promise<DeviceInfo[]>;
+    /**
+     * 토픽 구독
+     *
+     * @param topicName 토픽 이름
+     *
+     * @example
+     * ```typescript
+     * // 공지사항 토픽 구독
+     * await cb.push.subscribeTopic('announcements')
+     *
+     * // 마케팅 토픽 구독
+     * await cb.push.subscribeTopic('marketing')
+     * ```
+     */
+    subscribeTopic(topicName: string): Promise<void>;
+    /**
+     * 토픽 구독 해제
+     *
+     * @param topicName 토픽 이름
+     *
+     * @example
+     * ```typescript
+     * await cb.push.unsubscribeTopic('marketing')
+     * ```
+     */
+    unsubscribeTopic(topicName: string): Promise<void>;
+    /**
+     * 구독 중인 토픽 목록 조회
+     *
+     * @returns 구독 중인 토픽 이름 목록
+     */
+    getSubscribedTopics(): Promise<string[]>;
+    /**
+     * VAPID Public Key 조회 (Web Push용)
+     *
+     * @returns VAPID Public Key
+     *
+     * @example
+     * ```typescript
+     * const vapidKey = await cb.push.getVAPIDPublicKey()
+     *
+     * // Service Worker에서 Push 구독
+     * const registration = await navigator.serviceWorker.ready
+     * const subscription = await registration.pushManager.subscribe({
+     *     userVisibleOnly: true,
+     *     applicationServerKey: urlBase64ToUint8Array(vapidKey.public_key)
+     * })
+     *
+     * // 구독 정보 등록
+     * await cb.push.registerWebPush(subscription)
+     * ```
+     */
+    getVAPIDPublicKey(): Promise<VAPIDPublicKeyResponse>;
+    /**
+     * Web Push 구독 등록
+     *
+     * @param subscription PushSubscription 객체 또는 WebPushSubscription
+     *
+     * @example
+     * ```typescript
+     * // 브라우저에서 Push 구독 후 등록
+     * const registration = await navigator.serviceWorker.ready
+     * const subscription = await registration.pushManager.subscribe({
+     *     userVisibleOnly: true,
+     *     applicationServerKey: vapidPublicKey
+     * })
+     *
+     * await cb.push.registerWebPush(subscription)
+     * ```
+     */
+    registerWebPush(subscription: PushSubscription | WebPushSubscription): Promise<DeviceInfo>;
+    /**
+     * Web Push 구독 해제
+     */
+    unregisterWebPush(): Promise<void>;
+    /**
+     * 브라우저 고유 ID 생성 (localStorage에 저장)
+     */
+    private generateDeviceId;
+    /**
+     * 브라우저 이름 감지
+     */
+    private getBrowserName;
+    /**
+     * OS 정보 감지
+     */
+    private getOSInfo;
+}
+
+interface Video {
+    id: string;
+    channel_id: string;
+    title: string;
+    description?: string;
+    status: VideoStatus;
+    visibility: VideoVisibility;
+    duration?: number;
+    original_filename: string;
+    original_size: number;
+    qualities: VideoQuality[];
+    thumbnail_url?: string;
+    stream_url?: string;
+    tags?: string[];
+    view_count: number;
+    like_count: number;
+    comment_count: number;
+    created_at: string;
+    updated_at: string;
+}
+type VideoStatus = 'uploading' | 'processing' | 'ready' | 'failed';
+type VideoVisibility = 'public' | 'private' | 'unlisted' | 'members_only' | 'ppv';
+interface VideoQuality {
+    quality: string;
+    width: number;
+    height: number;
+    bitrate: number;
+    size: number;
+    status: 'pending' | 'processing' | 'ready' | 'failed';
+}
+interface VideoListResponse {
+    videos: Video[];
+    total: number;
+    page: number;
+    limit: number;
+}
+interface VideoListOptions {
+    status?: VideoStatus;
+    visibility?: VideoVisibility;
+    search?: string;
+    channel_id?: string;
+    page?: number;
+    limit?: number;
+}
+interface UploadOptions {
+    title: string;
+    description?: string;
+    visibility?: VideoVisibility;
+    tags?: string[];
+    channel_id?: string;
+    onProgress?: (progress: UploadProgress) => void;
+}
+interface UploadProgress {
+    phase: 'uploading' | 'processing' | 'complete';
+    uploadedChunks: number;
+    totalChunks: number;
+    percentage: number;
+    currentSpeed?: number;
+}
+interface UpdateVideoRequest {
+    title?: string;
+    description?: string;
+    visibility?: VideoVisibility;
+    tags?: string[];
+    thumbnail_url?: string;
+}
+interface StreamURLResponse {
+    url: string;
+    expires_at: string;
+    quality?: string;
+}
+interface InitUploadResponse {
+    session_id: string;
+    video_id: string;
+    chunk_size: number;
+    total_chunks: number;
+}
+interface TranscodeStatus {
+    video_id: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    progress: number;
+    qualities: QualityProgress[];
+    error?: string;
+}
+interface QualityProgress {
+    quality: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    progress: number;
+}
+interface WaitOptions {
+    timeout?: number;
+    interval?: number;
+    onProgress?: (progress: UploadProgress) => void;
+}
+interface Channel {
+    id: string;
+    owner_id: string;
+    handle: string;
+    name: string;
+    description?: string;
+    avatar_url?: string;
+    banner_url?: string;
+    subscriber_count: number;
+    video_count: number;
+    total_views: number;
+    is_verified: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateChannelRequest {
+    handle: string;
+    name: string;
+    description?: string;
+}
+interface UpdateChannelRequest {
+    name?: string;
+    description?: string;
+    avatar_url?: string;
+    banner_url?: string;
+}
+interface Playlist {
+    id: string;
+    channel_id: string;
+    title: string;
+    description?: string;
+    visibility: VideoVisibility;
+    thumbnail_url?: string;
+    video_count: number;
+    total_duration: number;
+    created_at: string;
+    updated_at: string;
+}
+interface CreatePlaylistRequest {
+    title: string;
+    description?: string;
+    visibility?: VideoVisibility;
+}
+interface PlaylistItem {
+    id: string;
+    playlist_id: string;
+    video_id: string;
+    position: number;
+    video?: Video;
+    added_at: string;
+}
+interface Shorts {
+    id: string;
+    channel_id: string;
+    video_id: string;
+    title: string;
+    description?: string;
+    visibility: VideoVisibility;
+    view_count: number;
+    like_count: number;
+    comment_count: number;
+    share_count: number;
+    is_remixable: boolean;
+    original_shorts_id?: string;
+    created_at: string;
+}
+interface ShortsListResponse {
+    shorts: Shorts[];
+    total: number;
+    next_cursor?: string;
+}
+interface VideoComment {
+    id: string;
+    video_id: string;
+    member_id: string;
+    content: string;
+    parent_id?: string;
+    like_count: number;
+    reply_count: number;
+    is_pinned: boolean;
+    is_hearted: boolean;
+    member?: {
+        id: string;
+        name: string;
+        avatar_url?: string;
+    };
+    created_at: string;
+    updated_at: string;
+}
+interface CommentListResponse {
+    comments: VideoComment[];
+    total: number;
+    next_cursor?: string;
+}
+interface WatchHistoryItem {
+    id: string;
+    video_id: string;
+    video?: Video;
+    watch_duration: number;
+    completed: boolean;
+    last_position: number;
+    watched_at: string;
+}
+interface MembershipTier {
+    id: string;
+    channel_id: string;
+    name: string;
+    description?: string;
+    level: number;
+    price: number;
+    currency: string;
+    billing_period: 'monthly' | 'yearly';
+    perks: string[];
+    badge_url?: string;
+    badge_color?: string;
+    member_count: number;
+    is_active: boolean;
+}
+interface ChannelMembership {
+    id: string;
+    channel_id: string;
+    member_id: string;
+    tier_id: string;
+    tier?: MembershipTier;
+    status: 'active' | 'cancelled' | 'expired' | 'paused';
+    started_at: string;
+    expires_at?: string;
+}
+interface SuperChat {
+    id: string;
+    video_id: string;
+    member_id: string;
+    amount: number;
+    currency: string;
+    message?: string;
+    color: string;
+    display_duration: number;
+    status: 'pending' | 'confirmed' | 'refunded';
+    member?: {
+        id: string;
+        name: string;
+        avatar_url?: string;
+    };
+    created_at: string;
+}
+
+declare class VideoProcessingError extends Error {
+    video?: Video;
+    constructor(message: string, video?: Video);
+}
+/**
+ * Video API for uploading, streaming, and managing videos
+ */
+declare class VideoAPI {
+    private http;
+    private videoBaseUrl;
+    constructor(http: HttpClient, videoBaseUrl?: string);
+    private getDefaultVideoUrl;
+    private getPublicPrefix;
+    private videoFetch;
+    /**
+     * Upload a video file with chunked upload support
+     */
+    upload(file: File, options: UploadOptions): Promise<Video>;
+    /**
+     * Wait for video processing to complete
+     */
+    waitForReady(videoId: string, options?: WaitOptions): Promise<Video>;
+    /**
+     * List videos
+     */
+    list(options?: VideoListOptions): Promise<VideoListResponse>;
+    /**
+     * Get a single video
+     */
+    get(videoId: string): Promise<Video>;
+    /**
+     * Update video details
+     */
+    update(videoId: string, data: UpdateVideoRequest): Promise<Video>;
+    /**
+     * Delete a video
+     */
+    delete(videoId: string): Promise<void>;
+    /**
+     * Get streaming URL for a video
+     */
+    getStreamUrl(videoId: string, quality?: string): Promise<StreamURLResponse>;
+    /**
+     * Get available thumbnails for a video
+     */
+    getThumbnails(videoId: string): Promise<string[]>;
+    /**
+     * Get transcode status
+     */
+    getTranscodeStatus(videoId: string): Promise<TranscodeStatus>;
+    /**
+     * Retry failed transcoding
+     */
+    retryTranscode(videoId: string): Promise<void>;
+    /**
+     * Create a channel
+     */
+    createChannel(data: CreateChannelRequest): Promise<Channel>;
+    /**
+     * Get a channel
+     */
+    getChannel(channelId: string): Promise<Channel>;
+    /**
+     * Get channel by handle
+     */
+    getChannelByHandle(handle: string): Promise<Channel>;
+    /**
+     * Update channel
+     */
+    updateChannel(channelId: string, data: UpdateChannelRequest): Promise<Channel>;
+    /**
+     * Subscribe to a channel
+     */
+    subscribeChannel(channelId: string): Promise<void>;
+    /**
+     * Unsubscribe from a channel
+     */
+    unsubscribeChannel(channelId: string): Promise<void>;
+    /**
+     * Create a playlist
+     */
+    createPlaylist(channelId: string, data: CreatePlaylistRequest): Promise<Playlist>;
+    /**
+     * Get playlists for a channel
+     */
+    getPlaylists(channelId: string): Promise<Playlist[]>;
+    /**
+     * Get playlist items
+     */
+    getPlaylistItems(playlistId: string): Promise<PlaylistItem[]>;
+    /**
+     * Add video to playlist
+     */
+    addToPlaylist(playlistId: string, videoId: string, position?: number): Promise<PlaylistItem>;
+    /**
+     * Remove video from playlist
+     */
+    removeFromPlaylist(playlistId: string, itemId: string): Promise<void>;
+    /**
+     * Get shorts feed
+     */
+    getShortsFeed(options?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<ShortsListResponse>;
+    /**
+     * Get trending shorts
+     */
+    getTrendingShorts(limit?: number): Promise<ShortsListResponse>;
+    /**
+     * Get a single shorts
+     */
+    getShorts(shortsId: string): Promise<Shorts>;
+    /**
+     * Get comments for a video
+     */
+    getComments(videoId: string, options?: {
+        cursor?: string;
+        limit?: number;
+        sort?: 'recent' | 'popular';
+    }): Promise<CommentListResponse>;
+    /**
+     * Post a comment
+     */
+    postComment(videoId: string, content: string, parentId?: string): Promise<VideoComment>;
+    /**
+     * Delete a comment
+     */
+    deleteComment(commentId: string): Promise<void>;
+    /**
+     * Like a video
+     */
+    likeVideo(videoId: string): Promise<void>;
+    /**
+     * Unlike a video
+     */
+    unlikeVideo(videoId: string): Promise<void>;
+    /**
+     * Get watch history
+     */
+    getWatchHistory(options?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        items: WatchHistoryItem[];
+        next_cursor?: string;
+    }>;
+    /**
+     * Clear watch history
+     */
+    clearWatchHistory(): Promise<void>;
+    /**
+     * Report watch progress
+     */
+    reportWatchProgress(videoId: string, position: number, duration: number): Promise<void>;
+    /**
+     * Get membership tiers for a channel
+     */
+    getMembershipTiers(channelId: string): Promise<MembershipTier[]>;
+    /**
+     * Join a membership tier
+     */
+    joinMembership(channelId: string, tierId: string): Promise<ChannelMembership>;
+    /**
+     * Cancel membership
+     */
+    cancelMembership(channelId: string, membershipId: string): Promise<void>;
+    /**
+     * Send a super chat
+     */
+    sendSuperChat(videoId: string, amount: number, message?: string, currency?: string): Promise<SuperChat>;
+    /**
+     * Get super chats for a video
+     */
+    getSuperChats(videoId: string): Promise<SuperChat[]>;
+    /**
+     * Get recommended videos
+     */
+    getRecommendations(limit?: number): Promise<Video[]>;
+    /**
+     * Get home feed
+     */
+    getHomeFeed(limit?: number): Promise<Video[]>;
+    /**
+     * Get related videos
+     */
+    getRelatedVideos(videoId: string, limit?: number): Promise<Video[]>;
+    /**
+     * Get trending videos
+     */
+    getTrendingVideos(limit?: number): Promise<Video[]>;
+    /**
+     * Submit recommendation feedback
+     */
+    submitFeedback(videoId: string, feedback: 'interested' | 'not_interested'): Promise<void>;
+}
+
+/**
+ * Game Server Types
+ */
+/**
+ * 게임 룸 설정
+ */
+interface GameRoomConfig {
+    /** 룸 ID (선택사항, 미지정시 자동 생성) */
+    roomId?: string;
+    /** 카테고리 ID (선택사항) */
+    categoryId?: string;
+    /** 틱 레이트 (TPS, 기본 64) */
+    tickRate?: number;
+    /** 최대 플레이어 수 (기본 100) */
+    maxPlayers?: number;
+    /** 커스텀 메타데이터 */
+    metadata?: Record<string, string>;
+}
+/**
+ * 게임 플레이어 정보
+ */
+interface GamePlayer {
+    clientId: string;
+    userId?: string;
+    joinedAt: number;
+    metadata?: Record<string, string>;
+}
+/**
+ * 게임 상태
+ */
+interface GameState {
+    roomId: string;
+    state: Record<string, unknown>;
+    version: number;
+    serverTime: number;
+    tickRate: number;
+    players: GamePlayer[];
+}
+/**
+ * 상태 변경 (델타)
+ */
+interface StateChange {
+    path: string;
+    operation: 'set' | 'delete';
+    value?: unknown;
+    oldValue?: unknown;
+}
+/**
+ * 게임 델타 업데이트
+ */
+interface GameDelta {
+    fromVersion: number;
+    toVersion: number;
+    changes: StateChange[];
+    tick: number;
+}
+/**
+ * 게임 액션
+ */
+interface GameAction {
+    type: string;
+    data?: unknown;
+    clientTimestamp?: number;
+    sequence?: number;
+}
+/**
+ * 룸 정보
+ */
+interface GameRoomInfo {
+    id: string;
+    appId: string;
+    categoryId?: string;
+    playerCount: number;
+    maxPlayers: number;
+    tickRate: number;
+    isRunning: boolean;
+    createdAt: number;
+    metadata?: Record<string, string>;
+}
+/**
+ * 게임 서버 메시지 타입
+ */
+type GameServerMessageType = 'room_created' | 'room_joined' | 'room_left' | 'state' | 'delta' | 'player_event' | 'chat' | 'pong' | 'room_list' | 'error';
+/**
+ * 게임 서버 메시지
+ */
+interface GameServerMessage<T = unknown> {
+    type: GameServerMessageType;
+    data: T;
+    serverTime: number;
+}
+/**
+ * 플레이어 이벤트
+ */
+interface PlayerEvent {
+    event: 'joined' | 'left';
+    roomId: string;
+    player: GamePlayer;
+    serverTime: number;
+}
+/**
+ * 채팅 메시지
+ */
+interface ChatMessage {
+    roomId: string;
+    clientId: string;
+    userId?: string;
+    message: string;
+    serverTime: number;
+}
+/**
+ * 에러 메시지
+ */
+interface ErrorMessage {
+    code: string;
+    message: string;
+}
+/**
+ * Ping/Pong 응답
+ */
+interface PongMessage {
+    clientTimestamp: number;
+    serverTimestamp: number;
+}
+/**
+ * 게임 클라이언트 이벤트 핸들러
+ */
+interface GameEventHandlers {
+    onConnect?: () => void;
+    onDisconnect?: (event: CloseEvent) => void;
+    onError?: (error: Event | ErrorMessage) => void;
+    onStateUpdate?: (state: GameState) => void;
+    onDelta?: (delta: GameDelta) => void;
+    onPlayerJoined?: (player: GamePlayer) => void;
+    onPlayerLeft?: (player: GamePlayer) => void;
+    onChat?: (message: ChatMessage) => void;
+    onPong?: (pong: PongMessage) => void;
+}
+/**
+ * 게임 클라이언트 설정
+ */
+interface GameClientConfig {
+    /** 게임 서버 URL */
+    gameServerUrl?: string;
+    /** API Key */
+    apiKey?: string;
+    /** 액세스 토큰 */
+    accessToken?: string;
+    /** 클라이언트 ID */
+    clientId: string;
+    /** 자동 재연결 여부 */
+    autoReconnect?: boolean;
+    /** 재연결 최대 시도 횟수 */
+    maxReconnectAttempts?: number;
+    /** 재연결 간격 (ms) */
+    reconnectInterval?: number;
+    /** 연결 타임아웃 (ms) */
+    connectionTimeout?: number;
+}
+/**
+ * 게임 연결 상태
+ */
+type GameConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+/**
+ * 게임 연결 상태 정보
+ */
+interface GameConnectionState {
+    status: GameConnectionStatus;
+    transport: 'webtransport' | 'websocket' | null;
+    roomId: string | null;
+    latency: number | null;
+    reconnectAttempt?: number;
+    lastError?: Error;
+}
+
+/**
+ * 게임 룸 클라이언트
+ * WebSocket 연결을 관리하고 게임 상태를 동기화합니다.
+ */
+declare class GameRoom {
+    private ws;
+    private config;
+    private handlers;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private pingInterval;
+    private actionSequence;
+    private _roomId;
+    private _state;
+    private _isConnected;
+    constructor(config: GameClientConfig);
+    /**
+     * 현재 룸 ID
+     */
+    get roomId(): string | null;
+    /**
+     * 현재 게임 상태
+     */
+    get state(): GameState | null;
+    /**
+     * 연결 상태
+     */
+    get isConnected(): boolean;
+    /**
+     * 이벤트 핸들러 등록
+     */
+    on<K extends keyof GameEventHandlers>(event: K, handler: GameEventHandlers[K]): this;
+    /**
+     * 게임 서버에 연결
+     */
+    connect(roomId?: string): Promise<void>;
+    /**
+     * 연결 해제
+     */
+    disconnect(): void;
+    /**
+     * 룸 생성
+     */
+    createRoom(config?: GameRoomConfig): Promise<GameState>;
+    /**
+     * 룸 참가
+     */
+    joinRoom(roomId: string, metadata?: Record<string, string>): Promise<GameState>;
+    /**
+     * 룸 퇴장
+     */
+    leaveRoom(): Promise<void>;
+    /**
+     * 게임 액션 전송
+     */
+    sendAction(action: GameAction): void;
+    /**
+     * 채팅 메시지 전송
+     */
+    sendChat(message: string): void;
+    /**
+     * 현재 상태 요청
+     */
+    requestState(): Promise<GameState>;
+    /**
+     * 룸 목록 조회
+     */
+    listRooms(): Promise<GameRoomInfo[]>;
+    /**
+     * Ping 전송 (RTT 측정용)
+     */
+    ping(): Promise<number>;
+    private buildConnectionUrl;
+    private send;
+    private sendWithHandler;
+    private handleMessage;
+    private handleDelta;
+    private applyChange;
+    private handlePlayerEvent;
+    private scheduleReconnect;
+    private startPingInterval;
+    private stopPingInterval;
+}
+/**
+ * 게임 API
+ * HTTP 기반 게임 서버 관리 API
+ */
+declare class GameAPI {
+    private http;
+    private gameServerUrl;
+    constructor(http: HttpClient, gameServerUrl?: string);
+    /**
+     * 게임 룸 클라이언트 생성
+     */
+    createClient(config: Omit<GameClientConfig, 'gameServerUrl'>): GameRoom;
+    /**
+     * 룸 목록 조회 (HTTP)
+     */
+    listRooms(appId?: string): Promise<GameRoomInfo[]>;
+    /**
+     * 룸 상세 조회 (HTTP)
+     */
+    getRoom(roomId: string): Promise<GameRoomInfo>;
+    /**
+     * 룸 생성 (HTTP, gRPC 대안)
+     */
+    createRoom(appId: string, config?: GameRoomConfig): Promise<GameRoomInfo>;
+    /**
+     * 룸 삭제 (HTTP)
+     */
+    deleteRoom(roomId: string): Promise<void>;
+    private getHeaders;
+}
+
+/**
+ * WebTransport-based Game Client
+ *
+ * WebTransport provides lower latency than WebSocket by using:
+ * - UDP-based QUIC protocol
+ * - Unreliable datagrams for real-time game state
+ * - Reliable streams for critical messages
+ *
+ * Falls back to WebSocket if WebTransport is not supported.
+ */
+
+/**
+ * Transport type for game connection
+ */
+type TransportType = 'webtransport' | 'websocket' | 'auto';
+/**
+ * Extended game client config with transport options
+ */
+interface GameTransportConfig extends GameClientConfig {
+    /** Preferred transport type */
+    transport?: TransportType;
+    /** Use unreliable datagrams for state updates (WebTransport only) */
+    useUnreliableDatagrams?: boolean;
+    /** Maximum datagram size (WebTransport only) */
+    maxDatagramSize?: number;
+}
+/**
+ * Check if WebTransport is available
+ */
+declare function isWebTransportSupported(): boolean;
+/**
+ * GameRoomTransport - Game room client with WebTransport support
+ *
+ * Provides the same API as GameRoom but with WebTransport support for
+ * lower latency game state synchronization.
+ */
+declare class GameRoomTransport {
+    private transport;
+    private config;
+    private handlers;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private pingInterval;
+    private actionSequence;
+    private _roomId;
+    private _state;
+    private _isConnected;
+    private _connectionStatus;
+    private _lastError;
+    private _latency;
+    private _transportType;
+    private decoder;
+    private pendingHandlers;
+    private messageId;
+    constructor(config: GameTransportConfig);
+    private getDefaultGameServerUrl;
+    /**
+     * Current transport type being used
+     */
+    get transportType(): TransportType;
+    /**
+     * Current room ID
+     */
+    get roomId(): string | null;
+    /**
+     * Current game state
+     */
+    get state(): GameState | null;
+    /**
+     * Connection status
+     */
+    get isConnected(): boolean;
+    /**
+     * Connection state information
+     */
+    get connectionState(): GameConnectionState;
+    /**
+     * Current latency (ms)
+     */
+    get latency(): number;
+    /**
+     * Register event handler
+     */
+    on<K extends keyof GameEventHandlers>(event: K, handler: GameEventHandlers[K]): this;
+    /**
+     * Connect to game server
+     */
+    connect(roomId?: string): Promise<void>;
+    /**
+     * Disconnect from server
+     */
+    disconnect(): void;
+    /**
+     * Create a new room
+     */
+    createRoom(config?: GameRoomConfig): Promise<GameState>;
+    /**
+     * Join an existing room
+     */
+    joinRoom(roomId: string, metadata?: Record<string, string>): Promise<GameState>;
+    /**
+     * Leave current room
+     */
+    leaveRoom(): Promise<void>;
+    /**
+     * Send game action
+     * Uses unreliable transport (datagrams) when WebTransport is available
+     */
+    sendAction(action: GameAction, reliable?: boolean): void;
+    /**
+     * Send chat message
+     */
+    sendChat(message: string): void;
+    /**
+     * Request current state
+     */
+    requestState(): Promise<GameState>;
+    /**
+     * Ping server for latency measurement
+     */
+    ping(): Promise<number>;
+    private send;
+    private sendWithHandler;
+    private handleMessage;
+    private handleDelta;
+    private applyChange;
+    private handlePlayerEvent;
+    private scheduleReconnect;
+    private startPingInterval;
+    private stopPingInterval;
+}
+
+interface ConnectBaseConfig {
+    /**
+     * Connect Base API 서버 URL (선택사항)
+     * @default 'https://api.connectbase.world'
+     * @example 'https://api.connectbase.world'
+     */
+    baseUrl?: string;
+    /**
+     * Connect Base Socket 서버 URL (선택사항, 실시간 통신용)
+     * @default 'https://socket.connectbase.world'
+     * @example 'https://socket.connectbase.world'
+     */
+    socketUrl?: string;
+    /**
+     * Connect Base WebRTC 서버 URL (선택사항, 영상/음성 통화용)
+     * @default 'https://webrtc.connectbase.world'
+     * @example 'https://webrtc.connectbase.world'
+     */
+    webrtcUrl?: string;
+    /**
+     * Connect Base Video 서버 URL (선택사항, 동영상 업로드/스트리밍용)
+     * @default 'https://video.connectbase.world'
+     * @example 'https://video.connectbase.world'
+     */
+    videoUrl?: string;
+    /**
+     * Connect Base Game 서버 URL (선택사항, 실시간 멀티플레이어 게임용)
+     * @default 'https://game.connectbase.world'
+     * @example 'https://game.connectbase.world'
+     */
+    gameUrl?: string;
+    /**
+     * API Key (콘솔에서 발급)
+     */
+    apiKey?: string;
+    /**
+     * 토큰이 갱신될 때 호출되는 콜백
+     */
+    onTokenRefresh?: (tokens: {
+        accessToken: string;
+        refreshToken: string;
+    }) => void;
+    /**
+     * 인증 에러 발생 시 호출되는 콜백
+     */
+    onAuthError?: (error: Error) => void;
+    /**
+     * 에러 트래커 설정
+     */
+    errorTracker?: ErrorTrackerConfig;
+}
+/**
+ * Connect Base SDK
+ *
+ * @example
+ * ```typescript
+ * // 간단 초기화 (API Key만 필요)
+ * const cb = new ConnectBase({
+ *     apiKey: 'your-api-key'
+ * })
+ *
+ * // 커스텀 서버 URL 사용 시
+ * const cb = new ConnectBase({
+ *     baseUrl: 'https://your-server.com',
+ *     apiKey: 'your-api-key'
+ * })
+ *
+ * // 데이터 조회
+ * const data = await cb.database.getData('table-id')
+ *
+ * // 파일 업로드
+ * const file = await cb.storage.uploadFile('storage-id', myFile)
+ *
+ * // 서버리스 함수 실행
+ * const result = await cb.functions.invoke('function-id', { name: 'John' })
+ *
+ * // 실시간 통신 (채팅 등)
+ * await cb.realtime.connect()
+ * const chat = await cb.realtime.subscribe('chat-room-1')
+ * chat.onMessage((msg) => console.log(msg))
+ * await chat.send({ text: 'Hello!' })
+ * ```
+ */
+declare class ConnectBase {
+    private http;
+    /**
+     * 인증 API
+     */
+    readonly auth: AuthAPI;
+    /**
+     * 데이터베이스 API
+     */
+    readonly database: DatabaseAPI;
+    /**
+     * 스토리지 API
+     */
+    readonly storage: StorageAPI;
+    /**
+     * API Key 관리 API
+     */
+    readonly apiKey: ApiKeyAPI;
+    /**
+     * 서버리스 함수 API
+     */
+    readonly functions: FunctionsAPI;
+    /**
+     * 실시간 통신 API (WebSocket)
+     */
+    readonly realtime: RealtimeAPI;
+    /**
+     * WebRTC API (영상/음성 통화)
+     */
+    readonly webrtc: WebRTCAPI;
+    /**
+     * 에러 트래커 API (클라이언트 에러 리포팅)
+     */
+    readonly errorTracker: ErrorTrackerAPI;
+    /**
+     * OAuth API (소셜 로그인)
+     */
+    readonly oauth: OAuthAPI;
+    /**
+     * 결제 API (토스페이먼츠)
+     */
+    readonly payment: PaymentAPI;
+    /**
+     * 정기결제/구독 API
+     */
+    readonly subscription: SubscriptionAPI;
+    /**
+     * 푸시 알림 API
+     */
+    readonly push: PushAPI;
+    /**
+     * 비디오 API (동영상 업로드/스트리밍)
+     */
+    readonly video: VideoAPI;
+    /**
+     * 게임 API (실시간 멀티플레이어)
+     */
+    readonly game: GameAPI;
+    constructor(config?: ConnectBaseConfig);
+    /**
+     * 수동으로 토큰 설정 (기존 토큰으로 세션 복원 시)
+     */
+    setTokens(accessToken: string, refreshToken: string): void;
+    /**
+     * 토큰 제거
+     */
+    clearTokens(): void;
+    /**
+     * 설정 업데이트
+     */
+    updateConfig(config: Partial<ConnectBaseConfig>): void;
+}
+
+export { type AnonymousSignInRequest, type AnonymousSignInResponse, type AnonymousSignUpResponse, ApiError, type ApiKeyItem, type AppStatsResponse, AuthError, type AuthSettingsResponse, type BillingCycle, type BillingKeyResponse, type BulkCreateResponse, type BulkError, type CancelPaymentRequest, type CancelPaymentResponse, type CancelSubscriptionRequest, type CategoryInfo, type Channel, type ChannelMembership, type ChargeWithBillingKeyRequest, type ChargeWithBillingKeyResponse, type ChatMessage, type ClientMessage, type ColumnSchema, type CommentListResponse, type ConfirmBillingKeyRequest, type ConfirmPaymentRequest, type ConfirmPaymentResponse, ConnectBase, type ConnectBaseConfig, type ConnectedData, type ConnectionState, type CreateApiKeyRequest, type CreateApiKeyResponse, type CreateChannelRequest, type CreateColumnRequest, type CreateDataRequest, type CreateFolderRequest, type CreateFolderResponse, type CreatePlaylistRequest, type CreateSubscriptionRequest, type CreateTableRequest, type DataItem, type DataType, type DeleteWhereResponse, type DeviceInfo, type EnabledProviderInfo, type EnabledProvidersResponse, type ErrorHandler, type ErrorMessage, type ErrorReport, type ErrorTrackerConfig, type ErrorType, type FetchApiKeysResponse, type FetchDataResponse, type FetchFilesResponse, type FileItem, GameAPI, type GameAction, type GameClientConfig, type GameConnectionState, type GameConnectionStatus, type GameDelta, type GameEventHandlers, type GamePlayer, GameRoom, type GameRoomConfig, type GameRoomInfo, GameRoomTransport, type GameServerMessage, type GameServerMessageType, type GameState, type GameTransportConfig, type GetAuthorizationURLRequest, type GetAuthorizationURLResponse, type GuestMemberSignInResponse, type HistoryResponse, type ICEServer, type ICEServersResponse, type InitUploadResponse, type InvokeFunctionRequest, type InvokeFunctionResponse, type IssueBillingKeyRequest, type IssueBillingKeyResponse, type JoinRoomRequest, type JoinRoomResponse, type ListBillingKeysResponse, type ListSubscriptionPaymentsRequest, type ListSubscriptionPaymentsResponse, type ListSubscriptionsRequest, type ListSubscriptionsResponse, type MemberSignInRequest, type MemberSignInResponse, type MemberSignUpRequest, type MemberSignUpResponse, type MembershipTier, type MessageHandler, type MoveFileRequest, type OAuthCallbackRequest, type OAuthCallbackResponse, type OAuthProvider, type PauseSubscriptionRequest, type PaymentDetail, type PaymentStatus, type PeerInfo, type PlayerEvent, type Playlist, type PlaylistItem, type PongMessage, type PreparePaymentRequest, type PreparePaymentResponse, type PushPlatform, type QualityProgress, type QueryOptions, type RealtimeConnectOptions, type RealtimeMessage, type RegisterDeviceRequest, type RenameFileRequest, type RenameFileResponse, type RoomInfo, type RoomStats, type RoomsResponse, type SendOptions, type ServerMessage, type Shorts, type ShortsListResponse, type SignInRequest, type SignInResponse, type SignUpRequest, type SignUpResponse, type SignalingMessage, type SignalingMessageType, type StateChange, type StateChangeHandler, type StreamURLResponse, type SubscribeOptions, type SubscribeTopicRequest, type SubscribedData, type Subscription, type SubscriptionPaymentResponse, type SubscriptionPaymentStatus, type SubscriptionResponse, type SubscriptionStatus, type SuperChat, type TableSchema, type TranscodeStatus, type TransportType, type UpdateApiKeyRequest, type UpdateApiKeyResponse, type UpdateBillingKeyRequest, type UpdateChannelRequest, type UpdateColumnRequest, type UpdateDataRequest, type UpdateSubscriptionRequest, type UpdateVideoRequest, type UploadFileResponse, type UploadOptions, type UploadProgress, type UserInfo, type VAPIDPublicKeyResponse, type Video, type VideoComment, type VideoListOptions, type VideoListResponse, VideoProcessingError, type VideoQuality, type VideoStatus, type VideoVisibility, type WaitOptions, type WatchHistoryItem, type WebPushSubscription, type WebRTCConnectOptions, type WebRTCConnectionState, type WebRTCMode, type WhereCondition, type WhereOperator, ConnectBase as default, isWebTransportSupported };