declare module "aliceonboarding" {
  import "aliceonboarding";
  namespace aliceonboarding {
    export class OnboardingConfig {
      withUserToken(userToken: string): OnboardingConfig;
      withAddSelfieStage(selfieStage: {
        selfieStageConfig?: SelfieStageConfig;
        selfieType?: SelfieType;
      }): OnboardingConfig;
      withAddDocumentStage(documentStage: {
        documentType: DocumentType;
        issuingCountry?: string;
        documentStageConfig?: DocumentStageConfig;
      }): OnboardingConfig;
      withAddAnyDocumentStage(anyDocumentStage: {
        issuingCountry?: string;
        allowedTypes?: Array<DocumentType>;
        documentStageConfig?: DocumentStageConfig;
      }): OnboardingConfig;
      withAddOtherTrustedDocumentStage(addOthertTrustedDocumentStage: {
        title: string;
        category?: string;
        description?: string;
        capturerType?: DocumentCapturerType;
      }): OnboardingConfig;

      withCustomParameters(completeTimeout?: number): OnboardingConfig;
      withCustomLocalization(customLocalizaton: {
        language: string;
        customMessages?: {};
      }): OnboardingConfig;
      withTheme(theme: {
        theme: string;
        iconTheme?: string;
        iconVariant?: string;
        style?: object;
      }): OnboardingConfig;
      withQRURL(config: { url: string; displayPcButton: boolean }): OnboardingConfig;
    }
    export class Onboarding {
      constructor(onboarding: {
        idSelector: string;
        onboardingConfig: OnboardingConfig;
        onboardingURL?: string;
      });
      run(onSuccess: any, onFailure: any, onCancel: any): Onboarding;
      unmount(): void;
      static setEnvironment(environment: string): void;
    }

    export class OnboardingCommands {
      constructor(onboardingCommandsParams: {
        idSelector: string;
        userToken: string;
        config: OnboardingConfig;
        onboardingURL?: string;
      });
      static makeOnboardingCommands(onboardingCommandsParams: {
        idSelector: string;
        userToken: string;
        config: OnboardingConfig;
        onboardingURL?: string;
      }): Promise<OnboardingCommands>;
      addSelfie(addSelfieCommands: {
        onSuccess: onSuccessCallback;
        onError: onErrorCallback;
        onCancel: onCancelCallback;
        selfieStageConfig: SelfieStageConfig;
        selfieType?: SelfieType;
      }): void;
      createDocument(createDocCommands: {
        documentType: DocumentType;
        issuingCountry: string;
        onSuccess: onSuccessCreateDocumentCallback;
        onError: onErrorCallback;
      }): void;
      getDocumentProperties(documentProperties: {
        type: DocumentType;
        issuingCountry: string;
        onSuccess: onSuccessCallback;
        onError: onErrorCallback;
      }): void;
      addDocument(addDocumentCommands: {
        onSuccess: onSuccessCallback;
        onError: onErrorCallback;
        onCancel: onCancelCallback;
        documentId: string;
        documentType: DocumentType;
        issuingCountry: string;
        documentSide: string;
        documentStageConfig?: DocumentStageConfig;
      }): void;
      addAnyDocument(addAnyDocumentCommands: {
        onSuccess: onSuccessCallback;
        onError: onErrorCallback;
        onCancel: onCancelCallback;
        issuingCountry: string;
        allowedTypes: Array<DocumentType>;
        documentStageConfig: DocumentStageConfig;
      }): void;
      addOtherTrustedDocument(addOTDCommands: {
        onSuccess: onSuccessCallback;
        onError: onErrorCallback;
        onCancel: onCancelCallback;
        category?: string;
      }): void;
      getUserStatus(onSuccess: onSuccessUserStatusCallback, onError: onErrorCallback): void;
      authenticate(authenticate: {
        onSuccess: onSuccessCallback;
        onCancel: onCancelCallback;
        onError: onErrorCallback;
        selfieStageConfig?: SelfieStageConfig;
      }): void;
      getDocumentsSupported(getDocumentsSupported: {
        onSuccess: onSuccessSupportedDocumentsCallback;
        onError: onErrorCallback;
      }): void;
      unmount(): void;
      static setEnvironment(environment: string): void;
    }
    export class DocumentType {
      static IDCARD: string;
      static DRIVERLICENSE: string;
      static PASSPORT: string;
      static RESIDENCEPERMIT: string;
      static HEALTHINSURANCECARD: string;
    }

    export class SelfieType {
      static DEFAULT: string;
      static WITH_DOCUMENT_CHALLENGE: string;
    }

    export class DocumentCapturerType {
      static ALL: string;
      static CAMERA: string;
      static FILE: string;
    }

    export class CameraType {
      static FACE: string;
      static BACK: string;
    }

    export class DocumentStageConfig {
      capturerType: DocumentCapturerType;
      automaticCapture: boolean;
      cameraType: CameraType;
      manualCaptureTimeout: number;
      attemptsToShowManualAlert: number;

      constructor(documentStageConfig: {
        capturerType?: DocumentCapturerType;
        automaticCapture?: boolean;
        cameraType?: CameraType;
        manualCaptureTimeout?: number;
        attemptsToShowManualAlert?: number;
      });
    }

    export class SelfieStageConfig {
      showTutorial: boolean;
      showModal: boolean;
      constructor(selfieStageConfig: { showTutorial?: boolean; showModal?: boolean });
    }

    export class TrialAuthenticator {
      constructor(trialAuthenticatorParams: {
        sandboxToken: string;
        userInfo: any;
        environment?: string;
      });
      execute(): Promise<any>;
    }
    export class Authenticator {
      execute(): Promise<any>;
    }

    export class OnboardingClient {
      static getStatus(userToken: string): Promise<any>;
      static createDocument(createDocument: {
        userToken: string;
        type: DocumentType;
        issuingCountry: string;
      }): Promise<any>;
      static getDocumentProperties(getDocumentProperties: {
        userToken: string;
        type: DocumentType;
        issuingCountry: string;
      }): Promise<any>;
      static addDocument(addDocument: {
        userToken: string;
        documentId: string;
        image: Blob;
        side: string;
        manual: boolean;
        webcam?: boolean;
        boundingBox?: Rect;
      }): Promise<any>;
      static addSelfieFromFrames(addSelfieFromFrames: {
        userToken: string;
        frames: Blob[];
        angle?: number;
      }): Promise<any>;
      static addSelfie(addSelfie: {
        userToken: string;
        video: Blob;
        start?: number;
        duration?: number;
        angle?: number;
      }): Promise<any>;
      static addOtherTrustedDocument(addOtherTrustedDocument: {
        userToken: string;
        file: Blob;
        category?: string;
      }): Promise<any>;
      static supportedDocuments(userToken: string): Promise<any>;
      static authenticate(userToken: string, video: Blob): Promise<any>;
      static authenticateFromFrames(userToken: string, frames: Blob[]): Promise<any>;
      static config(userToken: string): Promise<any>;
    }

    export class OnboardingClientError {
      constructor(code: number, message: string);
    }

    export class OnboardingError {
      constructor(code: number, type: string, message: string);
    }
    export interface Document {
      document_id: string;
    }
    type Countries = Record<string, string>;
    export interface SupportedDocuments {
      hierarchy: {
        correspondences: Countries;
        driverlicense: {
          issuing_countries: Array<string>;
        };
        healthinsurancecard: {
          issuing_countries: Array<string>;
        };
        idcard: {
          issuing_countries: Array<string>;
        };
        passport: {
          issuing_countries: Array<string>;
        };
        residencepermit: {
          issuing_countries: Array<string>;
        };
      };
    }
    export interface Status {
      user: {
        authorized: boolean;
        created_at: string;
        device: {
          agent: string;
          agent_version: string;
          model: string;
          platform: string;
          platform_version: string;
        };
        document_limit_reached: {
          driverlicense: boolean;
          healthinsurancecard: boolean;
          idcard: boolean;
          passport: boolean;
          residencepermit: boolean;
        };
        documents: Document;
        email: string;
        first_name: string;
        last_name: string;
        selfie_limit_reached: boolean;
        updated_at: string;
        uploaded_documents: boolean;
        uploaded_face: boolean;
        user_id: string;
      };
    }
    export type onErrorCallback = (error: OnboardingError) => void;

    export type onCancelCallback = () => void;

    export type onSuccessCallback = () => void;
    export type onSuccessCreateDocumentCallback = (result: Document) => void;
    export type onSuccessUserStatusCallback = (result: Status) => void;
    export type onSuccessSupportedDocumentsCallback = (result: SupportedDocuments) => void;

    export class Rect {
      constructor(x: number, y: number, width: number, height: number);
    }
  }
  export = aliceonboarding;
}