@pelican-identity/auth-core 1.2.9 → 1.2.11

package/dist/index.d.ts

@@ -1,8 +1,198 @@
-export * from "./types/types";
-export { PelicanAuthentication } from "./engine/engine";
-export { CryptoService } from "./utilities/crypto";
-export { StateMachine } from "./utilities/stateMachine";
-export { Transport } from "./utilities/transport";
-export * from "./utilities/storage";
-export { BASEURL } from "./constants";
-//# sourceMappingURL=index.d.ts.map
+type AuthType = "login" | "signup" | "id-verification";
+type PelicanAuthState = "idle" | "initializing" | "awaiting-pair" | "paired" | "awaiting-auth" | "authenticated" | "confirmed" | "error" | "terminated";
+interface PelicanAuthConfig {
+    publicKey: string;
+    projectId: string;
+    authType: AuthType;
+    continuousMode?: boolean;
+    forceQRCode?: boolean;
+}
+type PelicanAuthEventMap = {
+    state: PelicanAuthState;
+    qr: string;
+    deeplink: string;
+    success: IdentityResult;
+    error: Error;
+};
+interface ISocketMessage {
+    type: "confirmed" | "request-passcode" | "client-terminated" | "phone-terminated" | "pair" | "paired" | "phone-auth-success" | "authenticate" | "confirm" | "register";
+    sessionID: string;
+    cipher?: string;
+    nonce?: string;
+    publicKey?: string;
+    url?: string;
+    authType?: AuthType;
+    projectId?: string;
+    grantedAttributes?: {
+        [key: string]: boolean;
+    };
+}
+interface IPhone {
+    id: number;
+    country: string;
+    callingCode: string;
+    number: string;
+    verifiedAt: string;
+    verificationProvider: string;
+}
+interface IEmail {
+    id: number;
+    value: string;
+    verifiedAt: string;
+    verificationProvider: string;
+}
+type IdCardTypes = "national id card" | "passport" | "driver's license" | "residence permit";
+interface IKycData {
+    id: number;
+    status?: "Approved" | "Declined" | "In Review";
+    document_type?: IdCardTypes;
+    document_number?: string;
+    personal_number?: string;
+    date_of_birth?: string | Date;
+    age?: number;
+    expiration_date?: string | Date;
+    date_of_issue?: string | Date;
+    issuing_state?: string;
+    issuing_state_name?: string;
+    first_name?: string;
+    last_name?: string;
+    full_name?: string;
+    gender?: string;
+    address?: string;
+    formatted_address?: string;
+    place_of_birth?: string;
+    marital_status?: string;
+    nationality?: string;
+    liveness_percentage?: number;
+    face_match_percentage?: number;
+    verified_at?: string | Date;
+}
+interface IUserData {
+    first_name?: string;
+    last_name?: string;
+    other_names?: string;
+    email?: IEmail;
+    phone?: IPhone;
+    dob?: string | Date;
+    gender?: "male" | "female" | "other";
+    country?: string;
+    state?: string;
+    city?: string;
+    address?: string;
+    occupation?: string;
+    company?: string;
+    website?: string;
+}
+interface IdentityResult {
+    user_id: string;
+    user_data?: IUserData;
+    id_verification: IKycData;
+    id_downloadurls?: {
+        front_of_card?: string;
+        back_of_card?: string;
+    };
+}
+interface PelicanWebAuthProps extends PelicanAuthConfig {
+    onClose?: () => void;
+    onSuccess: (result: IdentityResult) => void;
+    onError?: (error: Error) => void;
+    buttonComponent?: React.ReactElement;
+    buttonText?: string;
+}
+
+type Listener<T> = (payload: T) => void;
+declare class PelicanAuthentication {
+    private readonly crypto;
+    private readonly stateMachine;
+    private transport?;
+    private sessionId;
+    private sessionKey;
+    private visibilityHandler?;
+    private backupCheckTimeout?;
+    private useWebSocket;
+    private listeners;
+    private readonly config;
+    constructor(config: PelicanAuthConfig);
+    on<K extends keyof PelicanAuthEventMap>(event: K, cb: Listener<PelicanAuthEventMap[K]>): () => boolean;
+    start(): Promise<void>;
+    stop(): void;
+    destroy(): void;
+    private shouldUseWebSocket;
+    private startWebSocketFlow;
+    private handleWebSocketMessage;
+    private handleAuthSuccess;
+    private startDeepLinkFlow;
+    private clearBackupCheck;
+    private checkSession;
+    private emitQRCode;
+    private emitDeepLink;
+    private attachVisibilityRecovery;
+    private detachVisibilityRecovery;
+    private fetchRelayUrl;
+    private terminate;
+    private restartIfContinuous;
+    private resetSession;
+    private emit;
+    private fail;
+}
+
+interface EncryptedMessage {
+    cipher: string;
+    nonce: string;
+}
+declare class CryptoService {
+    generateSymmetricKey(): string;
+    encryptSymmetric({ plaintext, keyString, }: {
+        plaintext: string;
+        keyString: string;
+    }): EncryptedMessage;
+    decryptSymmetric({ encrypted, keyString, }: {
+        encrypted: EncryptedMessage;
+        keyString: string;
+    }): string | null;
+}
+
+declare class StateMachine {
+    private state;
+    private listeners;
+    get current(): PelicanAuthState;
+    transition(next: PelicanAuthState): void;
+    subscribe(fn: (s: PelicanAuthState) => void): () => boolean;
+}
+
+type TransportHandlers = {
+    onOpen?: () => void;
+    onMessage?: (msg: ISocketMessage) => void;
+    onError?: (err: Event) => void;
+    onClose?: (ev: CloseEvent) => void;
+};
+declare class Transport {
+    private socket?;
+    private handlers;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private isExplicitlyClosed;
+    private url?;
+    private reconnectTimeout?;
+    private isReconnecting;
+    constructor(handlers: TransportHandlers);
+    connect(url: string): void;
+    private attemptReconnect;
+    send(payload: ISocketMessage): void;
+    close(): void;
+    get readyState(): number | undefined;
+    get isOpen(): boolean;
+}
+
+interface AuthSession {
+    sessionId: string;
+    sessionKey: string;
+}
+declare const storeAuthSession: (sessionId: string, sessionKey: string, ttlMs?: number) => void;
+declare const getAuthSession: () => AuthSession | null;
+declare const clearAuthSession: () => void;
+declare const clearAllAuthData: () => void;
+
+declare const BASEURL = "http://192.168.1.9:8080";
+
+export { type AuthSession, type AuthType, BASEURL, CryptoService, type IEmail, type IKycData, type IPhone, type ISocketMessage, type IUserData, type IdCardTypes, type IdentityResult, type PelicanAuthConfig, type PelicanAuthEventMap, type PelicanAuthState, PelicanAuthentication, type PelicanWebAuthProps, StateMachine, Transport, clearAllAuthData, clearAuthSession, getAuthSession, storeAuthSession };