vesant-sdk 1.0.4

package/dist/kyc/index.d.mts

@@ -0,0 +1,734 @@
+import { e as RiskLevel, P as PaginationParams, B as BaseClient } from '../types-Bnsnejor.mjs';
+import { e as ProfileFilters, f as ProfileListResponse, C as CustomerProfile, d as CreateProfileRequest } from '../types-CqOLbaXk.mjs';
+
+/**
+ * TypeScript type definitions for CGS KYC Service API
+ *
+ * These types match the Go API structures in:
+ * - services/kyc-service/internal/domain/
+ * - services/kyc-service/internal/service/
+ * - services/kyc-service/internal/handler/
+ */
+
+type KycStatus = 'pending' | 'accepted' | 'declined' | 'review.pending' | 'unknown';
+type KycAlertStatus = 'pending' | 'in_progress' | 'resolved' | 'closed' | 'escalated';
+type KycAlertType = 'kyc' | 'fraud';
+type DocumentType = 'id_card' | 'driving_license' | 'passport';
+type ProofType = 'document' | 'document_two' | 'face' | 'address' | 'additional_document';
+type SupportedDocumentType = 'id_card' | 'passport' | 'driving_license';
+interface KycRequest {
+    id: string;
+    reference: string;
+    forward_reference?: string;
+    tenant_id: string;
+    first_name: string;
+    middle_name?: string;
+    last_name: string;
+    dob?: string;
+    full_address?: string;
+    email?: string;
+    id_verified: boolean;
+    address_verified: boolean;
+    face_verified: boolean;
+    age_verified: boolean;
+    status: KycStatus;
+    location?: string;
+    identity_hash?: string;
+    required_document_count: number;
+    supported_document_types?: SupportedDocumentType[];
+    is_id_verification_required: boolean;
+    is_face_verification_required: boolean;
+    is_address_verification_required: boolean;
+    is_age_verification_required: boolean;
+    callback_url: string;
+    redirect_url?: string;
+    declined_reason?: string;
+    accepted_reason?: string;
+    other_reason?: string;
+    warnings?: Record<string, Record<string, string>>;
+    proofs?: Proof[];
+    alerts?: KycAlert[];
+    risk_profile?: KycCustomerProfile;
+    created_at: string;
+    updated_at: string;
+}
+interface Proof {
+    id: string;
+    kyc_id: string;
+    type: ProofType;
+    document: string;
+    document_number?: string;
+    created_at: string;
+}
+interface ProofDownloadURL {
+    type: ProofType;
+    url: string;
+    expires_at: string;
+}
+interface KycCustomerProfile {
+    id: string;
+    tenant_id: string;
+    customer_id: string;
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+    risk_score: number;
+    risk_level: RiskLevel;
+    kyc_status?: string;
+    pep_status?: boolean;
+    sanctions_status?: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface KycAlert {
+    id: string;
+    kyc_id: string;
+    tenant_id: string;
+    alert_type: KycAlertType;
+    alert_text: string;
+    risk: RiskLevel;
+    assigned_for?: string;
+    reason?: string;
+    status: KycAlertStatus;
+    created_at: string;
+    updated_at: string;
+}
+interface KycAlertFilters {
+    kyc_id?: string | string[];
+    alert_type?: KycAlertType | KycAlertType[];
+    assigned_for?: string | string[];
+    status?: KycAlertStatus | KycAlertStatus[];
+    risk?: RiskLevel | RiskLevel[];
+    search?: string;
+    fromDate?: string;
+    toDate?: string;
+    sort_by?: string;
+    order?: 'ASC' | 'DESC';
+}
+interface KycAlertListResponse {
+    alerts: KycAlert[];
+    pagination: KycPagination;
+}
+interface UpdateKycAlertRequest {
+    assigned_for?: string;
+    reason?: string;
+    alert_type?: KycAlertType;
+    status?: KycAlertStatus;
+}
+interface KycPreferences {
+    id: string;
+    tenant_id: string;
+    approve_kyc_reasons: string[];
+    is_document_verification_required: boolean;
+    is_face_verification_required: boolean;
+    is_address_verification_required: boolean;
+    is_age_verification_required: boolean;
+    min_age: number;
+    max_age: number;
+    required_document_count: number;
+    critical_risk_score: number;
+    high_risk_score: number;
+    medium_risk_score: number;
+    supported_document_types: SupportedDocumentType[];
+    created_at: string;
+    updated_at: string;
+}
+interface UpdateKycPreferencesRequest {
+    reasons?: string[];
+    is_document_verification_required?: boolean;
+    is_face_verification_required?: boolean;
+    is_address_verification_required?: boolean;
+    is_age_verification_required?: boolean;
+    min_age?: number;
+    max_age?: number;
+    required_document_count?: number;
+    critical_risk_score?: number;
+    high_risk_score?: number;
+    medium_risk_score?: number;
+    supported_document_types?: SupportedDocumentType[];
+}
+interface Name {
+    first_name?: string;
+    middle_name?: string;
+    last_name?: string;
+    full_name?: string;
+}
+interface SubmittedDocument {
+    /** Base64 encoded document image */
+    proof: string;
+    /** Base64 additional document image (back side, etc.) */
+    additional_proof?: string;
+    /** Document number for search/verification */
+    document_number?: string;
+    /** Document types to verify against */
+    selected_type?: DocumentType[];
+    /** Extracted/provided name */
+    name?: Name;
+    /** Date of birth (YYYY-MM-DD) */
+    dob?: string;
+    /** Issue date (YYYY-MM-DD) */
+    issue_date?: string;
+    /** Expiry date (YYYY-MM-DD) */
+    expiry_date?: string;
+    /** Gender */
+    gender?: string;
+}
+interface FaceProof {
+    /** Base64 encoded face image or selfie */
+    proof: string;
+}
+interface DocumentVerificationRequest {
+    /** Customer reference ID */
+    reference: string;
+    /** Callback URL for async verification results */
+    callback_url: string;
+    /** Customer email */
+    email: string;
+    /** Country code (ISO 3166-1 alpha-2) */
+    country: string;
+    /** Language code */
+    language: string;
+    /** Full address for verification */
+    full_address?: string;
+    /** Base64 encoded address proof document */
+    address_proof?: string;
+    /** Primary document */
+    document: SubmittedDocument;
+    /** Secondary document (optional) */
+    document_two?: SubmittedDocument;
+    /** Face verification proof (optional) */
+    face?: FaceProof;
+    /** Additional metadata */
+    token?: string;
+}
+interface DocumentVerificationResponse {
+    id: string;
+    reference: string;
+    status: KycStatus;
+    verification_url?: string;
+    message?: string;
+}
+interface UpdateKycStatusRequest {
+    /** Shufti reference or KYC ID */
+    reference: string;
+    /** Target status */
+    status: KycStatus;
+    /** Acceptance/decline reason */
+    reason?: string;
+    /** Shufti warnings data */
+    warnings?: Record<string, Record<string, string>>;
+}
+interface RequestKycSubmitLinkRequest {
+    /** User ID to generate KYC submission link for */
+    user_id: string;
+}
+interface RequestKycSubmitLinkResponse {
+    /** Generated KYC submission redirect URL */
+    link: string;
+}
+interface CheckKycStatusRequest {
+    /** User ID to check KYC status for */
+    user_id: string;
+    /** Authentication token */
+    kyc_id: string;
+}
+interface CheckKycStatusResponse {
+    /** User ID */
+    user_id?: string;
+    /** Token generated from cgs-server */
+    kyc_id: string;
+    /** Current KYC status */
+    status: string;
+    /** Reason/message for the status */
+    message: string;
+}
+interface RequestAdditionalDocumentsRequest {
+    /** KYC request ID */
+    id: string;
+    /** Document types to request */
+    document_types: ProofType[];
+    /** Message to customer */
+    message?: string;
+}
+interface KycOverview {
+    total: number;
+    pending: number;
+    approved: number;
+    high_risk: number;
+    rejected: number;
+    id_verified: number;
+    address_verified: number;
+    face_verified: number;
+    rejections: number;
+    total_alerts: number;
+    pending_alerts: number;
+    resolved_alerts: number;
+}
+interface KycRequestFilters {
+    status?: KycStatus | KycStatus[];
+    search?: string;
+    fromDate?: string;
+    toDate?: string;
+    sortBy?: string;
+    order?: 'ASC' | 'DESC';
+}
+interface KycPagination {
+    limit: number;
+    page: number;
+    total: number;
+    totalPages: number;
+}
+interface KycRequestListResponse {
+    data: KycRequest[];
+    pagination: KycPagination;
+}
+
+interface KycClientConfig {
+    /** Base URL of the KYC Service API (e.g., "http://localhost:8088") */
+    baseURL: string;
+    /** Base URL of the Customer Risk Profile Service API (e.g., "http://localhost:8094") */
+    riskProfileBaseURL?: string;
+    /** Tenant ID for multi-tenancy */
+    tenantId: string;
+    /** API key or JWT token for authentication */
+    apiKey?: string;
+    /** User ID for operations requiring user context */
+    userId?: string;
+    /** Custom headers to include in every request */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds (default: 10000) */
+    timeout?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/** Base hook state with loading and error */
+interface BaseHookState {
+    loading: boolean;
+    error: Error | null;
+}
+/** Base options for hooks with auto-fetch capability */
+interface BaseAutoFetchOptions {
+    autoFetch?: boolean;
+}
+/** Base options for hooks with polling capability */
+interface BasePollOptions extends BaseAutoFetchOptions {
+    pollInterval?: number;
+}
+/** Base options for list hooks with filters and pagination */
+interface BaseListOptions<TFilters> extends BasePollOptions {
+    filters?: TFilters;
+    pagination?: PaginationParams;
+}
+interface UseKycSubmissionOptions {
+    onComplete?: (result: DocumentVerificationResponse) => void;
+    onError?: (error: Error) => void;
+}
+interface UseKycSubmissionResult extends BaseHookState {
+    submit: (request: DocumentVerificationRequest) => Promise<DocumentVerificationResponse>;
+    submission: DocumentVerificationResponse | null;
+    reset: () => void;
+}
+type UseKycRequestsOptions = BaseListOptions<KycRequestFilters>;
+interface UseKycRequestsResult extends BaseHookState {
+    requests: KycRequest[];
+    pagination: KycPagination | null;
+    fetchRequests: (filters?: KycRequestFilters, pagination?: PaginationParams) => Promise<void>;
+    getRequest: (id: string) => Promise<KycRequest>;
+    updateStatus: (reference: string, status: KycStatus, reason?: string) => Promise<void>;
+    refresh: () => Promise<void>;
+}
+type UseKycAlertsOptions = BaseListOptions<KycAlertFilters>;
+interface UseKycAlertsResult extends BaseHookState {
+    alerts: KycAlert[];
+    pagination: KycPagination | null;
+    fetchAlerts: (filters?: KycAlertFilters, pagination?: PaginationParams) => Promise<void>;
+    getAlert: (id: string) => Promise<KycAlert>;
+    updateAlert: (id: string, update: UpdateKycAlertRequest) => Promise<void>;
+    refresh: () => Promise<void>;
+}
+interface UseKycOverviewOptions extends BaseAutoFetchOptions {
+    fromDate?: string;
+    toDate?: string;
+}
+interface UseKycOverviewResult extends BaseHookState {
+    overview: KycOverview | null;
+    refresh: (fromDate?: string, toDate?: string) => Promise<void>;
+}
+interface UseKycPreferencesResult extends BaseHookState {
+    preferences: KycPreferences | null;
+    updatePreferences: (update: UpdateKycPreferencesRequest) => Promise<void>;
+    refresh: () => Promise<void>;
+}
+
+/**
+ * KycClient - TypeScript SDK for CGS KYC (Know Your Customer) Service
+ *
+ * Provides type-safe methods to interact with the KYC service API.
+ * Extends BaseClient for consistent retry logic, timeout handling, and error management.
+ */
+
+/**
+ * KycClient extends BaseClient for:
+ * - Consistent retry logic with exponential backoff
+ * - Unified error handling (CGSError, NetworkError, TimeoutError, etc.)
+ * - Automatic timeout management
+ * - Debug logging
+ *
+ * All KYC verification calls use requestWithRetry() to handle
+ * transient failures gracefully.
+ */
+declare class KycClient extends BaseClient {
+    private userId?;
+    private riskProfileBaseURL?;
+    constructor(config: KycClientConfig);
+    /**
+     * Set the user ID for operations requiring user context
+     */
+    setUserId(userId: string): void;
+    /**
+     * Get current user ID
+     */
+    getUserId(): string | undefined;
+    /**
+     * Build headers including user ID if available
+     */
+    private getUserHeaders;
+    /**
+     * Request a KYC submission redirect URL for a user
+     *
+     * Generates a link that the user can visit to submit their KYC documents.
+     *
+     * @param request - Request containing the user ID
+     * @returns Response containing the redirect link
+     *
+     * @example
+     * ```typescript
+     * const result = await client.requestKycSubmitLink({
+     *   user_id: "user_123"
+     * });
+     *
+     * console.log(`Redirect user to: ${result.link}`);
+     * ```
+     */
+    requestKycSubmitLink(request: RequestKycSubmitLinkRequest): Promise<RequestKycSubmitLinkResponse>;
+    /**
+     * Check KYC status for a user
+     *
+     * Returns the current KYC status:
+     * - "complete" → KYC verified, show "Continue to Login"
+     * - "processing" → Under review, show "Continue to Login"
+     * - "failed" / "declined" → Show error + retry option
+     * - "pending" / "in_progress" → Keep polling
+     *
+     * @param request - Request containing user_id and token
+     * @returns Response with kyc_status and message (reason)
+     *
+     * @example
+     * ```typescript
+     * const result = await client.checkKycStatus({
+     *   user_id: "user_123",
+     *   token: "auth_token_xyz"
+     * });
+     *
+     * if (result.kyc_status === 'complete') {
+     *   // Show "Continue to Login"
+     * } else if (result.kyc_status === 'failed' || result.kyc_status === 'declined') {
+     *   // Show error + retry option
+     * } else {
+     *   // Keep polling
+     * }
+     * ```
+     */
+    checkKycStatus(request: CheckKycStatusRequest): Promise<CheckKycStatusResponse>;
+    /**
+     * Submit a document verification request with OCR
+     *
+     * Uses requestWithRetry() for automatic retry on transient failures.
+     *
+     * @param request - Document verification request with documents and customer info
+     * @returns Verification response with status and reference
+     *
+     * @example
+     * ```typescript
+     * const result = await client.submitVerification({
+     *   reference: "customer_123",
+     *   email: "customer@example.com",
+     *   country: "US",
+     *   document: {
+     *     proof: base64EncodedImage,
+     *     selected_type: ["id_card", "passport"],
+     *     name: { first_name: "John", last_name: "Doe" },
+     *     dob: "1990-01-15"
+     *   },
+     *   face: {
+     *     proof: base64EncodedSelfie
+     *   }
+     * });
+     *
+     * console.log(`Verification submitted: ${result.reference}`);
+     * ```
+     */
+    submitVerification(request: DocumentVerificationRequest): Promise<DocumentVerificationResponse>;
+    /**
+     * Get a KYC request by ID
+     *
+     * @param id - KYC request ID
+     * @returns KYC request details including proofs and alerts
+     *
+     * @example
+     * ```typescript
+     * const kyc = await client.getKycRequest("kyc_abc123");
+     * console.log(`Status: ${kyc.status}, ID Verified: ${kyc.id_verified}`);
+     * ```
+     */
+    getKycRequest(id: string): Promise<KycRequest>;
+    /**
+     * List KYC requests with filters and pagination
+     *
+     * @param filters - Optional filters (status, search, date range)
+     * @param pagination - Optional pagination (page, page_size)
+     * @returns Paginated list of KYC requests
+     *
+     * @example
+     * ```typescript
+     * const requests = await client.listKycRequests(
+     *   { status: "pending", search: "john" },
+     *   { page: 1, page_size: 20 }
+     * );
+     * console.log(`Found ${requests.total} pending requests`);
+     * ```
+     */
+    listKycRequests(filters?: KycRequestFilters, pagination?: PaginationParams): Promise<KycRequestListResponse>;
+    /**
+     * Update KYC request status (accept/decline)
+     *
+     * @param request - Status update request with reference, status, and reason
+     *
+     * @example
+     * ```typescript
+     * // Accept a KYC request
+     * await client.updateKycStatus({
+     *   reference: "shufti_ref_123",
+     *   status: "accepted",
+     *   reason: "All documents verified successfully"
+     * });
+     *
+     * // Decline a KYC request
+     * await client.updateKycStatus({
+     *   reference: "shufti_ref_456",
+     *   status: "declined",
+     *   reason: "Document expired"
+     * });
+     * ```
+     */
+    updateKycStatus(request: UpdateKycStatusRequest): Promise<void>;
+    /**
+     * Request additional documents from customer
+     *
+     * @param request - Request with KYC ID and document types needed
+     *
+     * @example
+     * ```typescript
+     * await client.requestAdditionalDocuments({
+     *   id: "kyc_abc123",
+     *   document_types: ["address", "document_two"],
+     *   message: "Please provide proof of address and secondary ID"
+     * });
+     * ```
+     */
+    requestAdditionalDocuments(request: RequestAdditionalDocumentsRequest): Promise<void>;
+    /**
+     * Get downloadable URLs for KYC proofs/documents
+     *
+     * @param kycId - KYC request ID
+     * @returns Array of proof download URLs with expiration
+     *
+     * @example
+     * ```typescript
+     * const proofs = await client.getProofDownloadURLs("kyc_abc123");
+     * proofs.forEach(proof => {
+     *   console.log(`${proof.type}: ${proof.url} (expires: ${proof.expires_at})`);
+     * });
+     * ```
+     */
+    getProofDownloadURLs(kycId: string): Promise<ProofDownloadURL[]>;
+    /**
+     * Get KYC overview statistics
+     *
+     * @param fromDate - Optional start date (ISO 8601)
+     * @param toDate - Optional end date (ISO 8601)
+     * @returns KYC statistics including counts by status
+     *
+     * @example
+     * ```typescript
+     * const overview = await client.getOverview(
+     *   "2024-01-01T00:00:00Z",
+     *   "2024-12-31T23:59:59Z"
+     * );
+     * console.log(`Total: ${overview.total}, Pending: ${overview.pending}`);
+     * console.log(`Approved: ${overview.approved}, Rejected: ${overview.rejected}`);
+     * ```
+     */
+    getOverview(fromDate?: string, toDate?: string): Promise<KycOverview>;
+    /**
+     * Get a KYC alert by ID
+     *
+     * @param alertId - Alert ID
+     * @returns Alert details
+     */
+    getAlert(alertId: string): Promise<KycAlert>;
+    /**
+     * List KYC alerts with filters and pagination
+     *
+     * @param filters - Optional filters (status, risk, alert_type, assigned_for, etc.)
+     * @param pagination - Optional pagination (page, page_size)
+     * @returns Paginated list of alerts
+     *
+     * @example
+     * ```typescript
+     * const alerts = await client.listAlerts(
+     *   {
+     *     status: ["pending", "in_progress"],
+     *     risk: "critical",
+     *     alert_type: "kyc"
+     *   },
+     *   { page: 1, page_size: 20 }
+     * );
+     * console.log(`Found ${alerts.total} alerts`);
+     * ```
+     */
+    listAlerts(filters?: KycAlertFilters, pagination?: PaginationParams): Promise<KycAlertListResponse>;
+    /**
+     * Update a KYC alert
+     *
+     * @param alertId - Alert ID
+     * @param update - Fields to update (status, assigned_for, reason, alert_type)
+     *
+     * @example
+     * ```typescript
+     * // Assign an alert
+     * await client.updateAlert("alert_123", {
+     *   assigned_for: "analyst_user_id",
+     *   status: "in_progress"
+     * });
+     *
+     * // Resolve an alert
+     * await client.updateAlert("alert_123", {
+     *   status: "resolved",
+     *   reason: "Customer verified via phone call"
+     * });
+     *
+     * // Escalate an alert
+     * await client.updateAlert("alert_123", {
+     *   status: "escalated",
+     *   assigned_for: "manager_user_id",
+     *   reason: "Requires senior review - suspicious documents"
+     * });
+     * ```
+     */
+    updateAlert(alertId: string, update: UpdateKycAlertRequest): Promise<void>;
+    /**
+     * Get KYC preferences for the tenant
+     *
+     * @returns KYC preferences configuration
+     *
+     * @example
+     * ```typescript
+     * const prefs = await client.getPreferences();
+     * console.log(`Face verification required: ${prefs.is_face_verification_required}`);
+     * console.log(`Required documents: ${prefs.required_document_count}`);
+     * ```
+     */
+    getPreferences(): Promise<KycPreferences>;
+    /**
+     * Update KYC preferences for the tenant
+     *
+     * @param update - Fields to update
+     * @returns Updated preferences
+     *
+     * @example
+     * ```typescript
+     * await client.updatePreferences({
+     *   is_face_verification_required: true,
+     *   is_address_verification_required: true,
+     *   required_document_count: 2,
+     *   reasons: [
+     *     "Documents verified",
+     *     "Identity confirmed",
+     *     "Address matched"
+     *   ]
+     * });
+     * ```
+     */
+    updatePreferences(update: UpdateKycPreferencesRequest): Promise<KycPreferences>;
+    /**
+     * Make a request to the Risk Profile Service
+     * Uses riskProfileBaseURL if configured, otherwise falls back to baseURL
+     */
+    private riskProfileRequest;
+    /**
+     * List customer profiles for the tenant
+     *
+     * @param filters - Optional filters (risk_category, entity_type, status, search, etc.)
+     * @param pagination - Optional pagination (limit, offset)
+     * @returns Paginated list of customer profiles
+     *
+     * @example
+     * ```typescript
+     * const profiles = await client.listCustomerProfiles(
+     *   { risk_category: 'high', entity_type: 'individual' },
+     *   { limit: 20, offset: 0 }
+     * );
+     * console.log(`Found ${profiles.total} profiles`);
+     * profiles.profiles.forEach(p => console.log(p.customer_id, p.full_name));
+     * ```
+     */
+    listCustomerProfiles(filters?: ProfileFilters, pagination?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ProfileListResponse>;
+    /**
+     * Get a customer profile by ID
+     *
+     * @param profileId - The profile UUID
+     * @returns Customer profile details
+     *
+     * @example
+     * ```typescript
+     * const profile = await client.getCustomerProfile('uuid-here');
+     * console.log(`Customer: ${profile.full_name}, Risk: ${profile.risk_category}`);
+     * ```
+     */
+    getCustomerProfile(profileId: string): Promise<CustomerProfile>;
+    /**
+     * Create a new customer profile
+     *
+     * A customer profile must exist before submitting KYC verification.
+     * The customer_id field will be used as the 'reference' in KYC submissions.
+     *
+     * @param profile - Customer profile data
+     * @returns Created customer profile
+     *
+     * @example
+     * ```typescript
+     * const profile = await client.createCustomerProfile({
+     *   customer_id: 'cust_123',
+     *   entity_type: 'individual',
+     *   full_name: 'John Doe',
+     *   email_address: 'john@example.com',
+     *   country_of_residence: 'US'
+     * });
+     * console.log(`Created profile: ${profile.id}`);
+     *
+     * // Now you can submit KYC using the customer_id as reference
+     * await client.submitVerification({
+     *   reference: profile.customer_id, // 'cust_123'
+     *   email: 'john@example.com',
+     *   // ... other fields
+     * });
+     * ```
+     */
+    createCustomerProfile(profile: CreateProfileRequest): Promise<CustomerProfile>;
+}
+
+export { type CheckKycStatusRequest, type CheckKycStatusResponse, CreateProfileRequest as CreateCustomerProfileRequest, CustomerProfile, ProfileFilters as CustomerProfileFilters, ProfileListResponse as CustomerProfileListResponse, type DocumentType, type DocumentVerificationRequest, type DocumentVerificationResponse, type FaceProof, type KycAlert, type KycAlertFilters, type KycAlertListResponse, type KycAlertStatus, type KycAlertType, KycClient, type KycClientConfig, type KycCustomerProfile, type KycOverview, type KycPagination, type KycPreferences, type KycRequest, type KycRequestFilters, type KycRequestListResponse, type KycStatus, type Name, PaginationParams, type Proof, type ProofDownloadURL, type ProofType, type RequestAdditionalDocumentsRequest, type RequestKycSubmitLinkRequest, type RequestKycSubmitLinkResponse, RiskLevel, type SubmittedDocument, type SupportedDocumentType, type UpdateKycAlertRequest, type UpdateKycPreferencesRequest, type UpdateKycStatusRequest, type UseKycAlertsOptions, type UseKycAlertsResult, type UseKycOverviewOptions, type UseKycOverviewResult, type UseKycPreferencesResult, type UseKycRequestsOptions, type UseKycRequestsResult, type UseKycSubmissionOptions, type UseKycSubmissionResult };