@ollaid/native-sso 1.0.0

package/dist/provider.d.ts

@@ -0,0 +1,38 @@
+/**
+ * NativeSSOProvider — React Context pour @ollaid/native-sso
+ * Centralise la configuration pour les hooks et composants individuels
+ *
+ * @version 1.0.0
+ */
+import { type ReactNode } from 'react';
+export interface NativeSSOConfig {
+    /** URL du Backend SaaS (ex: https://mon-saas.com/api) */
+    saasApiUrl: string;
+    /** URL du Backend IAM (ex: https://identityam.ollaid.com/api) */
+    iamApiUrl: string;
+    /** Timeout en ms (défaut: 30000) */
+    timeout?: number;
+    /** Mode debug (logs console) */
+    debug?: boolean;
+}
+export interface NativeSSOProviderProps {
+    config: NativeSSOConfig;
+    children: ReactNode;
+}
+/**
+ * Provider React pour centraliser la config SSO.
+ *
+ * Usage :
+ * ```tsx
+ * <NativeSSOProvider config={{ saasApiUrl: '...', iamApiUrl: '...' }}>
+ *   <App />
+ * </NativeSSOProvider>
+ * ```
+ */
+export declare function NativeSSOProvider({ config, children }: NativeSSOProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook pour accéder à la config SSO depuis le Provider.
+ * Optionnel : les hooks acceptent aussi la config en paramètre.
+ */
+export declare function useNativeSSOConfig(): NativeSSOConfig;
+export default NativeSSOProvider;

package/dist/services/api.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Client API pour @ollaid/native-sso
+ * Gestion des requêtes HTTP avec timeout, device ID, token storage
+ *
+ * @version 1.0.0
+ */
+export type ApiErrorType = 'network' | 'timeout' | 'server' | 'validation' | 'auth' | 'unknown';
+export declare class ApiError extends Error {
+    type: ApiErrorType;
+    statusCode?: number;
+    errorType?: string;
+    response?: unknown;
+    constructor(message: string, type: ApiErrorType, statusCode?: number, errorType?: string, response?: unknown);
+}
+export interface NativeAuthConfig {
+    /** URL du Backend SaaS (pour config et exchange) */
+    saasApiUrl: string;
+    /** URL du Backend IAM (pour encrypt, init, validate, etc.) */
+    iamApiUrl: string;
+    /** Timeout en ms (défaut: 30000) */
+    timeout?: number;
+    /** Mode debug (logs console) */
+    debug?: boolean;
+}
+export declare const setNativeAuthConfig: (newConfig: Partial<NativeAuthConfig>) => void;
+export declare const getNativeAuthConfig: () => NativeAuthConfig;
+export declare const isDebugMode: () => boolean;
+export declare const getDeviceId: () => string;
+declare const STORAGE: {
+    readonly AUTH_TOKEN: "auth_token";
+    readonly TOKEN: "token";
+    readonly USER: "user";
+    readonly ACCOUNT_TYPE: "account_type";
+};
+export declare const setAuthToken: (token: string) => void;
+export declare const getAuthToken: () => string | null;
+export declare const clearAuthToken: () => void;
+export declare const setAuthUser: (user: unknown) => void;
+export declare const getAuthUser: <T>() => T | null;
+export declare const setAccountType: (type: string) => void;
+export declare const getAccountType: () => string | null;
+export { STORAGE as STORAGE_KEYS };
+export declare function fetchWithTimeout<T>(url: string, options: RequestInit, timeout: number): Promise<T>;
+export declare function getHeaders(token?: string): HeadersInit;
+declare const _default: {
+    getConfig: () => NativeAuthConfig;
+    setConfig: (newConfig: Partial<NativeAuthConfig>) => void;
+};
+export default _default;

package/dist/services/debugLogger.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Debug Logger pour @ollaid/native-sso
+ * Stocke l'historique des appels API en mémoire pour le DebugPanel
+ * @version 1.0.0
+ */
+export interface ApiCallLog {
+    id: string;
+    timestamp: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    endpoint: string;
+    requestBody: unknown;
+    requestHeaders?: Record<string, string>;
+    responseStatus: number | null;
+    responseBody: unknown;
+    duration: number;
+    error?: string;
+}
+export declare function logApiCall(method: ApiCallLog['method'], endpoint: string, requestBody: unknown, requestHeaders?: Record<string, string>): string;
+export declare function logApiResponse(logId: string, responseStatus: number, responseBody: unknown, startTime: number, error?: string): void;
+export declare function getApiLogs(): ApiCallLog[];
+export declare function clearApiLogs(): void;
+export declare function subscribeToLogs(callback: (logs: ApiCallLog[]) => void): () => void;
+export declare function exportLogsAsText(): string;

package/dist/services/iamAccount.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Service IAM Account — APIs server-to-server
+ * link-phone, link-email, refresh-user-info, update-avatar, reset-avatar
+ *
+ * ⚠️ ATTENTION — SERVER-TO-SERVER UNIQUEMENT
+ * Ces APIs utilisent la `secret_key` de votre application IAM.
+ * Elles doivent être appelées EXCLUSIVEMENT depuis un backend (Node.js, PHP, etc.).
+ * Ne JAMAIS appeler ces méthodes depuis du code frontend/navigateur car la
+ * secret_key serait exposée dans les DevTools réseau.
+ *
+ * @version 1.0.0
+ */
+import type { LinkPhoneRequest, LinkPhoneResponse, LinkEmailRequest, LinkEmailResponse, RefreshUserInfoSingleRequest, RefreshUserInfoSingleResponse, RefreshUserInfoBulkRequest, RefreshUserInfoBulkResponse, UpdateAvatarRequest, UpdateAvatarResponse, ResetAvatarRequest, ResetAvatarResponse } from '../types/native';
+export declare const iamAccountService: {
+    /**
+     * Lier un numéro de téléphone à un compte utilisateur existant
+     * POST {iamApiUrl}/iam/link-phone
+     */
+    linkPhone(params: Partial<Pick<LinkPhoneRequest, "app_key" | "secret_key">> & Omit<LinkPhoneRequest, "app_key" | "secret_key">): Promise<LinkPhoneResponse>;
+    /**
+     * Lier une adresse email à un compte utilisateur existant
+     * POST {iamApiUrl}/iam/link-email
+     */
+    linkEmail(params: Partial<Pick<LinkEmailRequest, "app_key" | "secret_key">> & Omit<LinkEmailRequest, "app_key" | "secret_key">): Promise<LinkEmailResponse>;
+    /**
+     * Récupérer les user_infos d'un utilisateur (mode single)
+     * POST {iamApiUrl}/iam/refresh-user-info
+     */
+    refreshUserInfo(params: Partial<Pick<RefreshUserInfoSingleRequest, "secret_key">> & Omit<RefreshUserInfoSingleRequest, "secret_key">): Promise<RefreshUserInfoSingleResponse>;
+    /**
+     * Récupérer les user_infos en bulk (max 100 alias_references)
+     * POST {iamApiUrl}/iam/refresh-user-info
+     */
+    refreshUserInfoBulk(params: Partial<Pick<RefreshUserInfoBulkRequest, "secret_key">> & Omit<RefreshUserInfoBulkRequest, "secret_key">): Promise<RefreshUserInfoBulkResponse>;
+    /**
+     * Mettre à jour l'avatar d'un utilisateur pour une application spécifique
+     * POST {iamApiUrl}/iam/update-avatar
+     */
+    updateAvatar(params: Partial<Pick<UpdateAvatarRequest, "app_key" | "secret_key">> & Omit<UpdateAvatarRequest, "app_key" | "secret_key">): Promise<UpdateAvatarResponse>;
+    /**
+     * Réinitialiser l'avatar d'un utilisateur (remettre à null pour utiliser l'image globale)
+     * POST {iamApiUrl}/iam/reset-avatar
+     */
+    resetAvatar(params: Partial<Pick<ResetAvatarRequest, "app_key" | "secret_key">> & Omit<ResetAvatarRequest, "app_key" | "secret_key">): Promise<ResetAvatarResponse>;
+};

package/dist/services/mobilePassword.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Service de récupération de mot de passe v1.0
+ * Architecture Frontend-First : Appels directs à l'IAM
+ *
+ * @version 1.0.0
+ */
+import { ApiError } from './api';
+import type { MobilePasswordInitResponse, MobilePasswordSelectMethodResponse, MobilePasswordResetResponse, MobilePasswordResendResponse } from '../types/mobile';
+export declare const mobilePasswordService: {
+    hasCredentials(): boolean;
+    loadCredentials(): Promise<import("..").NativeCredentials>;
+    initRecovery(email: string): Promise<MobilePasswordInitResponse>;
+    selectMethod(processToken: string, receiveChoice: "email" | "phone"): Promise<MobilePasswordSelectMethodResponse>;
+    validateOtpLocally(inputCode: string, storedCode: string): boolean;
+    reset(processToken: string, password: string): Promise<MobilePasswordResetResponse>;
+    resendOtp(processToken: string): Promise<MobilePasswordResendResponse>;
+};
+export { ApiError };
+export default mobilePasswordService;

package/dist/services/mobileRegistration.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Service d'inscription Mobile SSO v1.0
+ * Architecture Frontend-First : Appels directs à l'IAM via nativeAuth
+ *
+ * @version 1.0.0
+ */
+import type { MobileRegistrationFormData, MobileVerifyOtpResponse, MobileRegistrationCompleteResponse, MobileResendOtpResponse } from '../types/mobile';
+import type { NativeInitResponse } from '../types/native';
+export declare const mobileRegistrationService: {
+    /**
+     * Init registration via nativeAuth.register() (Frontend-First)
+     */
+    init(data: Omit<MobileRegistrationFormData, "password" | "password_confirmation">): Promise<NativeInitResponse>;
+    /**
+     * Verify OTP via nativeAuth.validate()
+     */
+    verifyOtp(processToken: string, otpCode: string): Promise<MobileVerifyOtpResponse>;
+    /**
+     * Complete registration with password
+     */
+    complete(processToken: string, password: string): Promise<MobileRegistrationCompleteResponse>;
+    /**
+     * Complete phone-only registration (no password)
+     */
+    completePhoneOnly(processToken: string): Promise<MobileRegistrationCompleteResponse>;
+    /**
+     * Resend OTP
+     */
+    resendOtp(processToken: string): Promise<MobileResendOtpResponse>;
+};
+export default mobileRegistrationService;

package/dist/services/nativeAuth.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Service d'authentification Native Mobile SSO v1.0
+ * Architecture Frontend-First : Direct IAM après encryption
+ *
+ * @version 1.0.0
+ */
+import type { NativeAuthType, NativeEncryptRequest, NativeEncryptResponse, NativeInitResponse, NativeValidateResponse, NativeGrantAccessResponse, NativeResendOtpResponse, NativeExchangeResponse, NativeCredentials } from '../types/native';
+export declare const nativeAuthService: {
+    hasCredentials(): boolean;
+    getCredentials(): NativeCredentials | null;
+    loadCredentials(): Promise<NativeCredentials>;
+    encrypt(type: NativeAuthType, data: Partial<NativeEncryptRequest>): Promise<NativeEncryptResponse>;
+    init(nativeToken: string): Promise<NativeInitResponse>;
+    validate(processToken: string, creds: {
+        password?: string;
+        otp_code?: string;
+    }): Promise<NativeValidateResponse>;
+    verifyTotp(processToken: string, totpCode: string): Promise<NativeValidateResponse>;
+    grantAccess(processToken: string): Promise<NativeGrantAccessResponse>;
+    resendOtp(processToken: string): Promise<NativeResendOtpResponse>;
+    exchange(callbackToken: string): Promise<NativeExchangeResponse>;
+    checkToken(token: string): Promise<{
+        valid: boolean;
+        user_infos?: import("../types/native").UserInfos;
+    }>;
+    logout(token?: string): Promise<{
+        success: boolean;
+    }>;
+    clearCredentials(): void;
+    loginEmail(email: string, accountType?: "user" | "admin"): Promise<NativeInitResponse>;
+    loginPhone(ccphone: string, phone: string, accountType?: "user" | "admin"): Promise<NativeInitResponse>;
+    loginAccessOtp(otpCode: string): Promise<NativeInitResponse>;
+    register(data: {
+        name: string;
+        email?: string;
+        ccphone: string;
+        phone: string;
+        town?: string;
+        country?: string;
+        registration_type?: "email" | "phone";
+    }): Promise<NativeInitResponse>;
+    registerPhoneOnly(data: {
+        name: string;
+        ccphone: string;
+        phone: string;
+        town?: string;
+        country?: string;
+    }): Promise<NativeInitResponse>;
+    recoverPassword(method: "email" | "phone", identifier: {
+        email?: string;
+        ccphone?: string;
+        phone?: string;
+    }): Promise<NativeInitResponse>;
+};
+export default nativeAuthService;

package/dist/types/mobile.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Types pour le password recovery et registration Mobile SSO v1.0
+ *
+ * @version 1.0.0
+ */
+export type MobilePasswordStatus = 'idle' | 'choice_required' | 'pending_otp' | 'pending_password' | 'completed';
+export interface MobilePasswordState {
+    processToken: string | null;
+    status: MobilePasswordStatus;
+    storedOtp: string | null;
+    receiveMode: 'email' | 'phone' | null;
+    maskedEmail: string | null;
+    maskedPhone: string | null;
+    loading: boolean;
+    error: string | null;
+    errorType: string | null;
+    credentialsLoaded: boolean;
+}
+export interface MobilePasswordInitResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'email_not_found' | 'phone_not_found' | 'validation_error' | string;
+    process_token?: string;
+    status?: string;
+    expires_at?: string;
+    otp_code?: string;
+    receive_mode?: 'email' | 'phone';
+    masked_email?: string;
+    masked_phone?: string;
+    has_phone?: boolean;
+    otp_code_dev?: string;
+}
+export interface MobilePasswordSelectMethodResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'invalid_token' | 'validation_error' | string;
+    process_token?: string;
+    status?: 'pending_otp';
+    otp_code?: string;
+    receive_mode?: 'email' | 'phone';
+    masked_contact?: string;
+}
+export interface MobilePasswordResetResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'weak_password' | 'token_expired' | 'invalid_token' | string;
+    status?: 'completed';
+}
+export interface MobilePasswordResendResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'cooldown_active' | 'session_expired' | string;
+    otp_code?: string;
+    receive_mode?: 'email' | 'phone';
+    cooldown_remaining?: number;
+}
+export type AccountType = 'email' | 'phone-only';
+export interface MobileRegistrationFormData {
+    name: string;
+    email: string;
+    ccphone: string;
+    phone: string;
+    address?: string;
+    town?: string;
+    country?: string;
+    password: string;
+    password_confirmation: string;
+    registration_type?: 'email' | 'phone';
+}
+export interface MobileRegistrationInitResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'email_exists' | 'phone_exists' | 'validation_error' | string;
+    process_token?: string;
+    status?: string;
+    expires_at?: string;
+    otp_code_dev?: string;
+    otp_method?: 'email' | 'sms';
+    otp_sent_to?: string;
+    conflict?: {
+        type: 'email' | 'phone';
+        masked_identifier: string;
+        options: {
+            can_login: boolean;
+            can_recover_by_email: boolean;
+            can_recover_by_sms: boolean;
+            masked_email?: string;
+            masked_phone?: string;
+        };
+    };
+}
+export interface MobileVerifyOtpResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'invalid_otp' | 'otp_expired' | 'max_attempts_exceeded' | string;
+    status?: string;
+    callback_token?: string;
+    expires_at?: string;
+    recovery_token?: string;
+}
+export interface MobileRegistrationCompleteResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'weak_password' | 'session_expired' | string;
+    callback_token?: string;
+    status?: 'completed';
+}
+export interface MobileResendOtpResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'cooldown_active' | 'session_expired' | string;
+    otp_code?: string;
+    cooldown_remaining?: number;
+    otp_code_dev?: string;
+}
+export interface MobileAuthFinalResponse {
+    success: boolean;
+    message?: string;
+    token: string;
+    expires_at: string;
+    user: {
+        reference: string;
+        name: string;
+        email?: string;
+        phone?: string;
+        image_url?: string;
+    };
+}

package/dist/types/native.d.ts

@@ -0,0 +1,289 @@
+/**
+ * Types pour l'authentification Native SSO v1.0
+ * Architecture Frontend-First avec encryption directe
+ *
+ * @version 1.0.0
+ */
+export type NativeAuthType = 'login_email' | 'login_phone' | 'login_access_otp' | 'register' | 'recovery_password';
+export type AccountType = 'email' | 'phone-only';
+export type RegistrationType = 'email' | 'phone';
+export type NativeAuthStatus = 'pending_password' | 'pending_otp' | 'pending_registration' | 'pending_2fa' | 'needs_access' | 'completed' | 'expired' | 'failed';
+export interface NativeCredentials {
+    appKey: string;
+    encryptedCredentials: string;
+}
+export interface NativeEncryptRequest {
+    type: NativeAuthType;
+    app_key: string;
+    encrypted_credentials: string;
+    email?: string;
+    ccphone?: string;
+    phone?: string;
+    otp_code?: string;
+    account_type?: 'user' | 'admin';
+    name?: string;
+    town?: string;
+    country?: string;
+    registration_type?: RegistrationType;
+    method?: 'email' | 'phone';
+}
+export interface NativeConfigResponse {
+    success: boolean;
+    app_key: string;
+    encrypted_credentials: string;
+    debug?: boolean;
+}
+export interface NativeEncryptResponse {
+    success: boolean;
+    native_token: string;
+    expires_in: number;
+    message?: string;
+}
+export interface NativeInitResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'email_not_found' | 'phone_not_found' | 'alias_disabled' | 'access_denied' | 'user_suspended' | 'invalid_token' | 'token_expired' | 'validation_error' | 'invalid_country_code' | string;
+    process_token?: string;
+    status?: NativeAuthStatus;
+    expires_at?: string;
+    needs_access?: boolean;
+    callback_token?: string;
+    otp_sent_to?: string;
+    otp_expires_in?: number;
+    otp_code_dev?: string;
+    otp_method?: 'email' | 'sms';
+    disabled_type?: 'email' | 'phone';
+    alternative_method?: 'email' | 'phone' | null;
+    alternative_email?: string;
+    alternative_phone?: string;
+    application?: {
+        id: number;
+        name: string;
+        logo?: string;
+    };
+    user?: {
+        id: number;
+        name: string;
+        email?: string;
+        image_url?: string;
+    };
+    prompt?: {
+        title: string;
+        message: string;
+        actions: ('grant_access' | 'cancel')[];
+    };
+    conflict?: {
+        type: 'email' | 'phone';
+        masked_identifier: string;
+        options: {
+            can_login: boolean;
+            can_recover_by_email: boolean;
+            can_recover_by_sms: boolean;
+            masked_email?: string;
+            masked_phone?: string;
+        };
+    };
+}
+export interface NativeValidateResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'invalid_password' | 'invalid_otp' | 'otp_expired' | 'max_attempts_exceeded' | 'session_expired' | 'invalid_token' | 'requires_2fa' | string;
+    callback_token?: string;
+    requires_2fa?: boolean;
+    status?: NativeAuthStatus;
+    needs_access?: boolean;
+    process_token?: string;
+    application?: {
+        id: number;
+        name: string;
+        logo?: string;
+    };
+    user?: {
+        id: number;
+        name: string;
+        email?: string;
+        image_url?: string;
+    };
+    prompt?: {
+        title: string;
+        message: string;
+        actions: string[];
+    };
+}
+export interface NativeGrantAccessResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'invalid_token' | 'access_exists' | string;
+    callback_token?: string;
+    status?: 'completed';
+}
+export interface NativeResendOtpResponse {
+    success: boolean;
+    message?: string;
+    error_type?: 'cooldown_active' | 'session_expired' | string;
+    cooldown_remaining?: number;
+    otp_sent_to?: string;
+    otp_expires_in?: number;
+    otp_code_dev?: string;
+}
+export interface NativeUser {
+    id?: number;
+    reference: string;
+    name: string;
+    email?: string | null;
+    phone?: string;
+    ccphone?: string;
+    image_url?: string;
+    account_type?: 'user' | 'client';
+    town?: string;
+    country?: string;
+    address?: string;
+    auth_2fa?: boolean;
+}
+export interface NativeExchangeResponse {
+    success: boolean;
+    message?: string;
+    error_type?: string;
+    debug_error?: string;
+    debug_file?: string;
+    token: string;
+    auth_token?: string;
+    expires_at: string;
+    user: NativeUser;
+    user_infos?: UserInfos;
+}
+export interface CheckTokenResponse {
+    success: boolean;
+    valid: boolean;
+    user_infos?: UserInfos;
+}
+export interface NativeAuthState {
+    credentialsLoaded: boolean;
+    processToken: string | null;
+    status: NativeAuthStatus | null;
+    user: NativeUser | null;
+    application: {
+        id: number;
+        name: string;
+        logo?: string;
+    } | null;
+    prompt: {
+        title: string;
+        message: string;
+        actions: string[];
+    } | null;
+    alternativeMethod: {
+        type: 'email' | 'phone';
+        value: string;
+    } | null;
+    conflict: {
+        type: 'email' | 'phone';
+        maskedIdentifier: string;
+        options: {
+            canLogin: boolean;
+            canRecoverByEmail: boolean;
+            canRecoverBySms: boolean;
+            maskedEmail?: string;
+            maskedPhone?: string;
+        };
+    } | null;
+    loading: boolean;
+    error: string | null;
+    errorType: string | null;
+    otpMethod?: 'email' | 'sms' | null;
+    otpSentTo?: string | null;
+}
+export interface UserInfos {
+    name: string;
+    email: string | null;
+    ccphone?: string;
+    phone?: string;
+    address?: string;
+    town?: string;
+    country?: string;
+    image_url?: string;
+    auth_2fa?: boolean;
+}
+export interface LinkPhoneRequest {
+    app_key: string;
+    secret_key: string;
+    iam_reference: string;
+    ccphone: string;
+    phone: string;
+}
+export interface LinkPhoneResponse {
+    success: boolean;
+    message: string;
+    user_reference?: string;
+    user_infos?: UserInfos;
+}
+export interface LinkEmailRequest {
+    app_key: string;
+    secret_key: string;
+    iam_reference: string;
+    email: string;
+}
+export interface LinkEmailResponse {
+    success: boolean;
+    message: string;
+    user_reference?: string;
+    user_infos?: UserInfos;
+}
+export interface RefreshUserInfoSingleRequest {
+    secret_key: string;
+    alias_reference: string;
+}
+export interface RefreshUserInfoSingleResponse {
+    success: boolean;
+    message?: string;
+    user_reference?: string;
+    alias_reference?: string;
+    login_type?: 'email' | 'phone';
+    user_infos?: UserInfos;
+}
+export interface RefreshUserInfoBulkRequest {
+    secret_key: string;
+    alias_references: string[];
+}
+export interface RefreshUserInfoBulkResponse {
+    success: boolean;
+    message?: string;
+    total_requested?: number;
+    total_found?: number;
+    total_errors?: number;
+    data?: Array<{
+        user_reference: string;
+        alias_reference: string;
+        login_type: 'email' | 'phone';
+        user_infos: UserInfos;
+    }>;
+    errors?: Array<{
+        alias_reference: string;
+        error: string;
+    }>;
+}
+export interface UpdateAvatarRequest {
+    app_key: string;
+    secret_key: string;
+    alias_reference: string;
+    avatar_url: string;
+}
+export interface UpdateAvatarResponse {
+    success: boolean;
+    message: string;
+    user_reference?: string;
+    alias_reference?: string;
+    user_infos?: UserInfos;
+}
+export interface ResetAvatarRequest {
+    app_key: string;
+    secret_key: string;
+    alias_reference: string;
+}
+export interface ResetAvatarResponse {
+    success: boolean;
+    message: string;
+    user_reference?: string;
+    alias_reference?: string;
+    user_infos?: UserInfos;
+}