vg-x07df 0.1.0

package/packages/sdk/src/generated/api/services.ts

@@ -0,0 +1,225 @@
+import type { CancelablePromise } from './core/CancelablePromise';
+import { OpenAPI } from './core/OpenAPI';
+import { request as __request } from './core/request';
+import type { HealthData, UserPresenceData, CallsData } from './models';
+
+export class HealthService {
+
+	/**
+	 * @returns any Service is healthy
+	 * @throws ApiError
+	 */
+	public static getHealth(): CancelablePromise<HealthData['responses']['GetHealth']> {
+		
+		return __request(OpenAPI, {
+			method: 'GET',
+			url: '/health',
+		});
+	}
+
+	/**
+	 * @returns any Service is healthy
+	 * @throws ApiError
+	 */
+	public static getSignalHealth(): CancelablePromise<HealthData['responses']['GetSignalHealth']> {
+		
+		return __request(OpenAPI, {
+			method: 'GET',
+			url: '/signal/health',
+		});
+	}
+
+}
+
+export class UserPresenceService {
+
+	/**
+	 * @returns any User presence retrieved successfully
+	 * @throws ApiError
+	 */
+	public static getSignalPresenceByUserId(data: UserPresenceData['payloads']['GetSignalPresenceByUserId']): CancelablePromise<UserPresenceData['responses']['GetSignalPresenceByUserId']> {
+		const {
+                    
+                    userId
+                } = data;
+		return __request(OpenAPI, {
+			method: 'GET',
+			url: '/signal/presence/{userId}',
+			path: {
+				userId
+			},
+			errors: {
+				400: `Invalid request`,
+				401: `Authentication required`,
+				404: `User not found or presence unavailable`,
+			},
+		});
+	}
+
+	/**
+	 * @returns any Bulk presence retrieved successfully
+	 * @throws ApiError
+	 */
+	public static getSignalPresenceBulk(data: UserPresenceData['payloads']['GetSignalPresenceBulk']): CancelablePromise<UserPresenceData['responses']['GetSignalPresenceBulk']> {
+		const {
+                    
+                    userIds
+                } = data;
+		return __request(OpenAPI, {
+			method: 'GET',
+			url: '/signal/presence/bulk',
+			query: {
+				userIds
+			},
+			errors: {
+				400: `Invalid request`,
+				401: `Authentication required`,
+			},
+		});
+	}
+
+}
+
+export class CallsService {
+
+	/**
+	 * @returns any Call started successfully
+	 * @throws ApiError
+	 */
+	public static postSignalCalls(data: CallsData['payloads']['PostSignalCalls']): CancelablePromise<CallsData['responses']['PostSignalCalls']> {
+		const {
+                    
+                    appId,
+requestBody
+                } = data;
+		return __request(OpenAPI, {
+			method: 'POST',
+			url: '/signal/calls',
+			query: {
+				appId
+			},
+			body: requestBody,
+			mediaType: 'application/json',
+			errors: {
+				400: `Invalid request`,
+				401: `Authentication required`,
+			},
+		});
+	}
+
+	/**
+	 * @returns any Call accepted successfully
+	 * @throws ApiError
+	 */
+	public static postSignalCallsByCallIdAccept(data: CallsData['payloads']['PostSignalCallsByCallIdAccept']): CancelablePromise<CallsData['responses']['PostSignalCallsByCallIdAccept']> {
+		const {
+                    
+                    callId,
+appId
+                } = data;
+		return __request(OpenAPI, {
+			method: 'POST',
+			url: '/signal/calls/{callId}/accept',
+			path: {
+				callId
+			},
+			query: {
+				appId
+			},
+			errors: {
+				400: `Invalid request`,
+				401: `Authentication required`,
+				403: `User is not a participant`,
+				404: `Call not found`,
+				409: `Call cannot be accepted in current state`,
+			},
+		});
+	}
+
+	/**
+	 * @returns any Call declined successfully
+	 * @throws ApiError
+	 */
+	public static postSignalCallsByCallIdDecline(data: CallsData['payloads']['PostSignalCallsByCallIdDecline']): CancelablePromise<CallsData['responses']['PostSignalCallsByCallIdDecline']> {
+		const {
+                    
+                    callId,
+appId
+                } = data;
+		return __request(OpenAPI, {
+			method: 'POST',
+			url: '/signal/calls/{callId}/decline',
+			path: {
+				callId
+			},
+			query: {
+				appId
+			},
+			errors: {
+				400: `Invalid request`,
+				401: `Authentication required`,
+				403: `User is not a participant`,
+				404: `Call not found`,
+				409: `Call cannot be declined in current state`,
+			},
+		});
+	}
+
+	/**
+	 * @returns any Left call successfully
+	 * @throws ApiError
+	 */
+	public static postSignalCallsByCallIdLeave(data: CallsData['payloads']['PostSignalCallsByCallIdLeave']): CancelablePromise<CallsData['responses']['PostSignalCallsByCallIdLeave']> {
+		const {
+                    
+                    callId,
+appId
+                } = data;
+		return __request(OpenAPI, {
+			method: 'POST',
+			url: '/signal/calls/{callId}/leave',
+			path: {
+				callId
+			},
+			query: {
+				appId
+			},
+			errors: {
+				400: `Invalid request`,
+				401: `Authentication required`,
+				403: `User is not a participant`,
+				404: `Call not found`,
+				409: `Call cannot be left in current state`,
+			},
+		});
+	}
+
+	/**
+	 * @returns any Call retrieved successfully
+	 * @throws ApiError
+	 */
+	public static getSignalCallsByCallId(data: CallsData['payloads']['GetSignalCallsByCallId']): CancelablePromise<CallsData['responses']['GetSignalCallsByCallId']> {
+		const {
+                    
+                    callId,
+appId
+                } = data;
+		return __request(OpenAPI, {
+			method: 'GET',
+			url: '/signal/calls/{callId}',
+			path: {
+				callId
+			},
+			query: {
+				appId
+			},
+			errors: {
+				400: `Invalid request`,
+				401: `Authentication required`,
+				403: `User does not have access to this call`,
+				404: `Call not found`,
+			},
+		});
+	}
+
+}

package/packages/sdk/src/hooks/index.ts

@@ -0,0 +1,21 @@
+// Core call management hooks
+export * from "./useCallState";
+export * from "./useCallActions";
+export * from "./useCallQuality";
+export * from "./useConnection";
+export * from "./useAutoJoin";
+
+// Participant management hooks
+export * from "./useParticipants";
+export * from "./useParticipantStatus";
+
+// Media control hooks
+export * from "./useMediaControls";
+export * from "./useDevices";
+
+// Event system hooks
+export * from "./useEvent";
+
+// Error handling and recovery hooks
+export * from "./useErrorRecovery";
+export { useErrors, useErrorsByCode, useErrorCount } from "./useErrors";

package/packages/sdk/src/hooks/useAutoJoin.ts

@@ -0,0 +1,66 @@
+import { useSdk } from "../provider/RtcProvider";
+import type { AutoJoinConfig } from "../core/types";
+
+export interface UseAutoJoinReturn {
+  /**
+   * Current auto-join configuration
+   */
+  config: AutoJoinConfig;
+  
+  /**
+   * Whether auto-join is enabled
+   */
+  isEnabled: boolean;
+  
+  /**
+   * Whether retry on failure is enabled
+   */
+  retryOnFailure: boolean;
+  
+  /**
+   * Get maximum retry attempts
+   */
+  maxRetries: number;
+}
+
+/**
+ * Hook to access auto-join configuration and utilities
+ */
+export function useAutoJoin(): UseAutoJoinReturn {
+  const sdk = useSdk();
+  const config = sdk.autoJoinConfig;
+
+  return {
+    config,
+    isEnabled: config.enabled,
+    retryOnFailure: config.retryOnFailure,
+    maxRetries: config.maxRetries,
+  };
+}
+
+/**
+ * Hook to determine if the current user should auto-join based on their role
+ */
+export function useAutoJoinForCurrentUser() {
+  const sdk = useSdk();
+  const autoJoin = useAutoJoin();
+  
+  // Get current user info from auth
+  const currentUserId = sdk.auth.getCurrentUserId();
+  
+  if (!currentUserId) {
+    return {
+      shouldAutoJoin: false,
+      reason: "No current user",
+    };
+  }
+  
+  return {
+    shouldAutoJoin: autoJoin.isEnabled,
+    reason: autoJoin.isEnabled 
+      ? "Auto-join enabled"
+      : "Auto-join disabled",
+  };
+}
+
+export type UseAutoJoinForCurrentUserReturn = ReturnType<typeof useAutoJoinForCurrentUser>;

package/packages/sdk/src/hooks/useCallActions.ts

@@ -0,0 +1,28 @@
+import { useSdk } from "../provider/RtcProvider";
+
+export function useCallActions() {
+  const sdk = useSdk();
+
+  return {
+    initiate: (participants: string[], type: "AUDIO" | "VIDEO") => {
+      return sdk.initiate({ invitees: participants, mode: type });
+    },
+    accept: (callId: string) => {
+      return sdk.accept(callId);
+    },
+    decline: (callId: string) => {
+      return sdk.decline(callId);
+    },
+    end: (callId: string) => {
+      return sdk.leave(callId);
+    },
+    cancel: (callId: string) => {
+      return sdk.leave(callId);
+    },
+    join: () => {
+      return sdk.join();
+    },
+  };
+}
+
+export type CallActionsHook = ReturnType<typeof useCallActions>;