@authing/react-ui-components 4.0.0-rc.0 → 4.0.0-rc.1

package/types/Guard/sso.d.ts

@@ -0,0 +1,19 @@
+import { User } from 'authing-js-sdk';
+export interface SessionData {
+    session: null | {
+        _id: string;
+        cookie: {
+            originalMaxAge: number;
+            expires: Date;
+            secure: boolean;
+            httpOnly: boolean;
+            path: string;
+            sameSite: string;
+        };
+        appId?: string;
+        type: string;
+        userId: string;
+    };
+    userInfo?: User;
+}
+export declare const trackSession: () => Promise<import("../_utils/http").AuthingGuardResponse<SessionData>>;

package/types/GuardButton/GuardButton.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { ButtonProps } from 'antd/lib/button';
+import './styles.less';
+export interface GuardButtonProps extends ButtonProps {
+}
+export declare const GuardButton: React.FC<GuardButtonProps>;

package/types/GuardButton/index.d.ts

@@ -0,0 +1 @@
+export * from './GuardButton';

package/types/IconFont/iconfont.d.ts

@@ -0,0 +1 @@
+export declare const GenerateSvg: (guardDocument: Document, svgString: string) => void;

package/types/IconFont/index.d.ts

@@ -0,0 +1,8 @@
+import React, { FC } from 'react';
+import './iconfont';
+import './style.less';
+export declare const IconFont: FC<{
+    type: string;
+    style?: React.CSSProperties;
+    className?: string;
+}>;

package/types/IconFont/useGuardIconfont.d.ts

@@ -0,0 +1 @@
+export declare const useGuardIconfont: (cdnBase?: string | undefined, setError?: any) => boolean;

package/types/IdentityBinding/IdentityBinding.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import './styles.less';
+export declare const GuardIdentityBindingView: React.FC;

package/types/IdentityBinding/businessRequest.d.ts

@@ -0,0 +1,33 @@
+export declare enum IdentityBindingBusinessAction {
+    PhoneCode = "phone-code",
+    EmailCode = "emial-code",
+    Password = "password"
+}
+export interface PhoneCodeParams {
+    phone: string;
+    code: string;
+    phoneCountryCode?: string;
+}
+export interface EmailCodeParams {
+    email: string;
+    code: string;
+}
+export interface PasswordParams {
+    account: string;
+    password: string;
+    captchaCode: string;
+}
+export declare enum IdentityBindingAction {
+    CreateUser = "create-federation-account",
+    BindByPassword = "bind-identity-by-password",
+    BindByPhoneCode = "bind-identity-by-phone-code",
+    BindByEmailCode = "bind-identity-by-email-code"
+}
+export declare const PhoneCode: (params: PhoneCodeParams) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+export declare const EmailCode: (params: EmailCodeParams) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+export declare const Password: (params: PasswordParams) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+export declare const useIdentityBindingBusinessRequest: () => {
+    "phone-code": (params: PhoneCodeParams) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+    "emial-code": (params: EmailCodeParams) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+    password: (params: PasswordParams) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+};

package/types/IdentityBinding/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IdentityBinding';
+export * from './interface';

package/types/IdentityBinding/interface.d.ts

@@ -0,0 +1,27 @@
+import { IG2Config, IG2Events, IG2FCProps, IG2FCViewProps } from '..';
+import { AuthenticationClient, User } from 'authing-js-sdk';
+import { GuardModuleType } from '../Guard';
+import { Agreement } from '../Type/application';
+export interface IdentityBindingConfig extends IG2Config {
+    autoRegister?: boolean;
+    publicKey?: string;
+    agreementEnabled?: boolean;
+    agreements?: Agreement[];
+}
+export interface IdentityBindingEvents extends IG2Events {
+    onBinding?: (user: User, authClient: AuthenticationClient) => void;
+    onBindingError?: (errorMessages: any) => void;
+    onLogin?: (user: User, authClient: AuthenticationClient) => void;
+    onLoginError?: (errorMessages: any) => void;
+}
+export interface GuardIdentityBindingProps extends IG2FCProps, IdentityBindingEvents {
+    config?: Partial<IdentityBindingConfig>;
+}
+export interface GuardIdentityBindingInitData {
+    methods: Array<'email' | 'username' | 'phone' | 'phone-code' | 'email-code'>;
+    source?: GuardModuleType;
+}
+export interface GuardIdentityBindingViewProps extends GuardIdentityBindingProps, IG2FCViewProps {
+    config: IdentityBindingConfig;
+    initData: GuardIdentityBindingInitData;
+}

package/types/IdentityBindingAsk/IdentityBindingAsk.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import './styles.less';
+export declare const GuardIdentityBindingAskView: React.FC;

package/types/IdentityBindingAsk/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IdentityBindingAsk';
+export * from './interface';

package/types/IdentityBindingAsk/interface.d.ts

@@ -0,0 +1,21 @@
+import { AuthenticationClient, User } from 'authing-js-sdk';
+import { IG2Config, IG2Events, IG2FCProps, IG2FCViewProps } from '..';
+export interface IdentityBindingAskConfig extends IG2Config {
+}
+export interface IdentityBindingAskEvents extends IG2Events {
+    onLogin?: (user: User, authClient: AuthenticationClient) => void;
+    onLoginError?: (errorMessages: any) => void;
+    onCreate?: (user: User, authClient: AuthenticationClient) => void;
+    onCreateError?: (errorMessages: any) => void;
+}
+export interface GuardIdentityBindingAskProps extends IG2FCProps, IdentityBindingAskEvents {
+    config?: Partial<IdentityBindingAskConfig>;
+    initData?: any;
+}
+export interface GuardIdentityBindingAskInitData {
+    methods: 'email' | 'username' | 'phone' | 'phone-code' | 'email-code';
+}
+export interface GuardIdentityBindingAskViewProps extends GuardIdentityBindingAskProps, IG2FCViewProps {
+    config: IdentityBindingAskConfig;
+    initData: GuardIdentityBindingAskInitData;
+}

package/types/ImagePro/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import './styles.less';
+export interface ImageProProps extends React.ImgHTMLAttributes<HTMLImageElement> {
+    src: string;
+    className?: string;
+    alt?: string;
+    imgClassName?: string;
+    size?: number | string;
+    width?: number | string;
+    height?: number | string;
+    borderRadius?: number | string;
+    noSpin?: boolean;
+}
+export declare const ImagePro: (props: ImageProProps) => JSX.Element;

package/types/InputNumber/index.d.ts

@@ -0,0 +1,5 @@
+import { InputProps } from 'antd/lib/input';
+import React from 'react';
+export interface InputNumberProps extends InputProps {
+}
+export declare const InputNumber: React.ForwardRefExoticComponent<InputNumberProps & React.RefAttributes<any>>;

package/types/InputPassword/index.d.ts

@@ -0,0 +1,4 @@
+import { Input } from 'antd';
+import { PasswordProps } from 'antd/lib/input';
+import React from 'react';
+export declare const InputPassword: React.ForwardRefExoticComponent<PasswordProps & React.RefAttributes<React.RefObject<Input>>>;

package/types/Login/codemap.d.ts

@@ -0,0 +1,2 @@
+import { GuardModuleAction } from '../Guard/module';
+export declare const codeMap: Record<number, GuardModuleAction>;

package/types/Login/core/withAD.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Agreement } from '../../Type/application';
+interface LoginWithADProps {
+    publicKey: string;
+    autoRegister?: boolean;
+    onLoginSuccess: any;
+    onLoginFailed: any;
+    onBeforeLogin: any;
+    agreements: Agreement[];
+}
+export declare const LoginWithAD: (props: LoginWithADProps) => JSX.Element;
+export {};

package/types/Login/core/withAppQrcode.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+interface LoginWithAppQrcodeProps {
+    onLoginSuccess: any;
+    canLoop: boolean;
+    qrCodeScanOptions: any;
+}
+export declare const LoginWithAppQrcode: (props: LoginWithAppQrcodeProps) => JSX.Element;
+export {};

package/types/Login/core/withLDAP.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { Agreement } from '../../Type/application';
+interface LoginWithLDAPProps {
+    publicKey: string;
+    autoRegister?: boolean;
+    host?: string;
+    onLoginSuccess: any;
+    onLoginFailed: any;
+    onBeforeLogin: any;
+    agreements: Agreement[];
+}
+export declare const LoginWithLDAP: (props: LoginWithLDAPProps) => JSX.Element;
+export {};

package/types/Login/core/withPassword/FormItemAccount.d.ts

@@ -0,0 +1,7 @@
+import { FormItemProps } from 'antd/lib/form';
+import React from 'react';
+import { PasswordLoginMethods } from '../../../Type/application';
+export interface FormItemAccountProps extends FormItemProps {
+    passwordLoginMethods: PasswordLoginMethods[];
+}
+export declare const FormItemAccount: React.FC<FormItemAccountProps>;

package/types/Login/core/withPassword/GraphicVerifyCode.d.ts

@@ -0,0 +1,7 @@
+import { InputProps } from 'antd/lib/input';
+import React from 'react';
+export interface GraphicVerifyCodeProps extends InputProps {
+    verifyCodeUrl: string;
+    changeCode: () => void;
+}
+export declare const GraphicVerifyCode: React.FC<GraphicVerifyCodeProps>;

package/types/Login/core/withPassword/InputAccount.d.ts

@@ -0,0 +1,7 @@
+import { InputProps } from 'antd/lib/input';
+import React from 'react';
+import { PasswordLoginMethods } from '../../../Type/application';
+export interface InputAccountProps extends InputProps {
+    passwordLoginMethods: PasswordLoginMethods[];
+}
+export declare const InputAccount: React.FC<InputAccountProps>;

package/types/Login/core/withPassword/index.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { AuthingResponse } from '../../../_utils/http';
+import { Agreement, LoginMethods, PasswordLoginMethods } from '../../../Type/application';
+interface LoginWithPasswordProps {
+    publicKey: string;
+    autoRegister?: boolean;
+    host?: string;
+    onBeforeLogin?: any;
+    onLoginSuccess?: any;
+    onLoginFailed?: any;
+    onLoginRequest?: (loginInfo: any) => Promise<AuthingResponse>;
+    passwordLoginMethods: PasswordLoginMethods[];
+    agreements: Agreement[];
+    loginWay?: LoginMethods;
+    submitButText?: string;
+    saveIdentify?: (type: LoginMethods, identity: string) => void;
+}
+export declare const LoginWithPassword: (props: LoginWithPasswordProps) => JSX.Element;
+export {};

package/types/Login/core/withVerifyCode/FormItemIdentify.d.ts

@@ -0,0 +1,11 @@
+import { FormItemProps } from 'antd/lib/form';
+import React from 'react';
+import { VerifyLoginMethods } from '../../../Type/application';
+export interface FormItemIdentifyProps extends FormItemProps {
+    checkRepeat?: boolean;
+    checkExist?: boolean;
+    methods: VerifyLoginMethods[];
+    currentMethod: 'phone-code' | 'email-code';
+    areaCode?: string;
+}
+export declare const FormItemIdentify: React.FC<FormItemIdentifyProps>;

package/types/Login/core/withVerifyCode/InputInternationPhone.d.ts

@@ -0,0 +1,7 @@
+import { InputProps } from 'antd/lib/input';
+import React from 'react';
+export interface InputInternationPhoneProps extends InputProps {
+    areaCode: string;
+    onAreaCodeChange: (areaCode: string) => void;
+}
+export declare const InputInternationPhone: React.FC<InputInternationPhoneProps>;

package/types/Login/core/withVerifyCode/VirtualDropdown.d.ts

@@ -0,0 +1,8 @@
+import React, { FC } from 'react';
+import './styles.less';
+export interface VirtualDropdownProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    style?: React.CSSProperties;
+}
+export declare const VirtualDropdown: FC<VirtualDropdownProps>;

package/types/Login/core/withVerifyCode/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import './styles.less';
+export declare const LoginWithVerifyCode: (props: any) => JSX.Element;

package/types/Login/core/withVerifyCode/inputIdentify.d.ts

@@ -0,0 +1,7 @@
+import { InputProps } from 'antd/lib/input';
+import React from 'react';
+import { VerifyLoginMethods } from '../../../Type/application';
+export interface InputIdentifyProps extends InputProps {
+    methods: VerifyLoginMethods[];
+}
+export declare const InputIdentify: React.FC<InputIdentifyProps>;

package/types/Login/core/withWechatMiniQrcode.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+interface LoginWithWechatMiniQrcodeProps {
+    onLoginSuccess: any;
+    canLoop: boolean;
+    qrCodeScanOptions: any;
+}
+export declare const LoginWithWechatMiniQrcode: (props: LoginWithWechatMiniQrcodeProps) => JSX.Element;
+export {};

package/types/Login/core/withWechatmpQrcode.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+interface LoginWithWechatmpQrcodeProps {
+    onLoginSuccess: any;
+    canLoop: boolean;
+    qrCodeScanOptions: any;
+}
+export declare const LoginWithWechatmpQrcode: (props: LoginWithWechatmpQrcodeProps) => JSX.Element;
+export {};

package/types/Login/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import './styles.less';
+export declare const GuardLoginView: () => JSX.Element;

package/types/Login/interface.d.ts

@@ -0,0 +1,37 @@
+import { IG2Config, IG2Events, IG2FCProps, IG2FCViewProps } from '../Type';
+import { AuthenticationClient, SocialConnectionProvider, User } from 'authing-js-sdk';
+import { QrCodeAuthenticationClient } from 'authing-js-sdk/build/main/lib/authentication/QrCodeAuthenticationClient';
+import { Agreement, LoginMethods, PasswordLoginMethods } from '../Type/application';
+export interface LoginConfig extends IG2Config {
+    autoRegister?: boolean;
+    disableResetPwd?: boolean;
+    disableRegister?: boolean;
+    defaultLoginMethod?: LoginMethods;
+    loginMethods?: LoginMethods[];
+    passwordLoginMethods?: PasswordLoginMethods[];
+    socialConnections?: SocialConnectionProvider[];
+    socialConnectionsBtnShape?: 'default' | 'button' | 'icon';
+    enterpriseConnections?: string[];
+    qrCodeScanOptions?: Parameters<QrCodeAuthenticationClient['startScanning']>[1];
+    publicKey?: string;
+    agreementEnabled?: boolean;
+    agreements?: Agreement[];
+}
+export interface LoginEvents extends IG2Events {
+    onLogin?: (user: User, authClient: AuthenticationClient) => void;
+    onLoginError?: (errorMessages: any) => void;
+    onLoginTabChange?: (activeTab: LoginMethods) => void;
+    onBeforeLogin?: (loginInfo: any, authClient: AuthenticationClient) => boolean | Promise<boolean>;
+}
+export interface GuardLoginProps extends IG2FCProps, LoginEvents {
+    config?: Partial<LoginConfig>;
+}
+export interface GuardLoginViewProps extends GuardLoginProps, IG2FCViewProps {
+    config: LoginConfig;
+}
+export interface GuardLoginInitData {
+    specifyDefaultLoginMethod?: LoginMethods;
+    _firstItemInitialValue?: string;
+    _lockMethod?: string;
+}
+export declare const getDefaultLoginConfig: () => LoginConfig;

package/types/Login/socialLogin/IdpButton/index.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const IdpButton: (props: any) => JSX.Element | null;

package/types/Login/socialLogin/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import './style.less';
+import { GuardLocalConfig } from '../../Guard';
+import { ApplicationConfig, SocialConnectionItem } from '../../Type/application';
+export interface SocialLoginProps {
+    appId: string;
+    config: GuardLocalConfig;
+    onLoginFailed: any;
+    onLoginSuccess: any;
+    enterpriseConnectionObjs: ApplicationConfig['identityProviders'];
+    socialConnectionObjs: SocialConnectionItem[];
+}
+export declare const SocialLogin: React.FC<SocialLoginProps>;

package/types/Login/socialLogin/postMessage.d.ts

@@ -0,0 +1,7 @@
+import { AuthingResponse } from '../../_utils/http';
+export declare const usePostMessage: () => (evt: MessageEvent) => import("../../_utils/http").AuthingGuardResponse<any> | {
+    code: any;
+    data: any;
+    onGuardHandling: undefined;
+} | undefined;
+export declare const useErrorHandling: () => (res: AuthingResponse) => import("../../_utils/http").AuthingGuardResponse<any>;

package/types/MFA/VerifyCodeInput/VerifyCodeFormItem.d.ts

@@ -0,0 +1,8 @@
+import { FormItemProps } from 'antd/lib/form';
+import React from 'react';
+import './style.less';
+export interface VerifyCodeFormItemProps extends FormItemProps {
+    codeLength: number;
+    ruleKeyword?: string;
+}
+export declare const VerifyCodeFormItem: React.FC<VerifyCodeFormItemProps>;

package/types/MFA/VerifyCodeInput/index.d.ts

@@ -0,0 +1,14 @@
+import React, { FC } from 'react';
+import './style.less';
+interface VerifyCodeInputProps extends React.HTMLAttributes<HTMLDivElement> {
+    length?: number;
+    size?: string;
+    gutter?: string;
+    onEenter?: Function;
+    showDivider?: boolean;
+    onChange?: any;
+    value?: Array<number | string>;
+    onFinish?: any;
+}
+export declare const VerifyCodeInput: FC<VerifyCodeInputProps>;
+export {};

package/types/MFA/businessRequest.d.ts

@@ -0,0 +1,46 @@
+export declare enum MfaBusinessAction {
+    VerifyEmail = "verify-email",
+    VerifySms = "verify-sms",
+    VerifyTotp = "verify-totp",
+    VerifyFace = "verify-face",
+    AssociateFace = "associate-face"
+}
+export declare const authFlow: (action: MfaBusinessAction, content: any) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+interface VerifySmsContent {
+    phone: string;
+    code: string;
+    mfaToken?: string;
+    phoneCountryCode?: string;
+}
+interface VerifyEmailContent {
+    email: string;
+    code: string;
+    mfaToken?: string;
+}
+interface VerifyTotpContent {
+    totp: string;
+    mfaToken?: string;
+}
+interface VerifyFaceContent {
+    photo: string;
+    mfaToken?: string;
+}
+interface AssociateFaceContent {
+    photoA: string;
+    photoB: string;
+    isExternalPhoto?: boolean;
+    mfaToken?: string;
+}
+export declare const VerifyEmail: (content: VerifyEmailContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+export declare const VerifySms: (content: VerifySmsContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+export declare const VerifyTotp: (content: VerifyTotpContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+export declare const VerifyFace: (content: VerifyFaceContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+export declare const AssociateFace: (content: AssociateFaceContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+export declare const useMfaBusinessRequest: () => {
+    "verify-email": (content: VerifyEmailContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+    "verify-sms": (content: VerifySmsContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+    "verify-totp": (content: VerifyTotpContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+    "verify-face": (content: VerifyFaceContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+    "associate-face": (content: AssociateFaceContent) => Promise<import("../_utils/http").AuthingGuardResponse<any>>;
+};
+export {};

package/types/MFA/codemap.d.ts

@@ -0,0 +1,2 @@
+import { GuardModuleAction } from '../Guard/module';
+export declare const codeMap: Record<number, GuardModuleAction>;

package/types/MFA/core/email.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { MFAConfig } from '../interface';
+interface BindMFAEmailProps {
+    mfaToken: string;
+    onBind: (email: string) => void;
+    config: any;
+}
+export declare const BindMFAEmail: React.FC<BindMFAEmailProps>;
+interface VerifyMFAEmailProps {
+    email: string;
+    mfaToken: string;
+    onVerify: (code: number, data: any) => void;
+    sendCodeRef: React.RefObject<HTMLButtonElement>;
+    codeLength: number;
+}
+export declare const VerifyMFAEmail: React.FC<VerifyMFAEmailProps>;
+export declare const MFAEmail: React.FC<{
+    mfaToken: string;
+    email?: string;
+    mfaLogin: any;
+    config: MFAConfig;
+}>;
+export {};

package/types/MFA/core/face.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const MFAFace: (props: any) => JSX.Element;

package/types/MFA/core/face_deps.d.ts

@@ -0,0 +1,11 @@
+export declare const devicesConstraints: {
+    video: {
+        width: number;
+        height: number;
+    };
+};
+export declare const FACE_SCORE = 0.65;
+export declare function getFaceDetectorOptions(): any;
+export declare function getCurrentFaceDetectionNet(): any;
+export declare function isFaceDetectionModelLoaded(): boolean;
+export declare function dataURItoBlob(base64Data: any): Blob;

package/types/MFA/core/sms.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { GuardMFAInitData, MFAConfig } from '../interface';
+export interface BindMFASmsProps {
+    mfaToken: string;
+    onBind: (phone: string) => void;
+    config: any;
+    areaCode: string;
+    setAreaCode: (areaCode: string) => void;
+    isInternationSms: boolean;
+}
+export declare const BindMFASms: React.FC<BindMFASmsProps>;
+export interface VerifyMFASmsProps {
+    mfaToken: string;
+    phone: string;
+    onVerify: (code: number, data: any) => void;
+    sendCodeRef: React.RefObject<HTMLButtonElement>;
+    codeLength: number;
+    areaCode: string;
+    phoneCountryCode?: string;
+    isInternationSms: boolean;
+    userPhone?: string;
+}
+export declare const VerifyMFASms: React.FC<VerifyMFASmsProps>;
+export declare const MFASms: React.FC<{
+    mfaLogin: any;
+    config: MFAConfig;
+    initData: GuardMFAInitData;
+}>;

package/types/MFA/core/totp.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { GuardMFAInitData, MFAConfig } from '../interface';
+export interface BindMFATotpProps {
+    initData: GuardMFAInitData;
+    changeModule: any;
+}
+export declare const BindMFATotp: React.FC<BindMFATotpProps>;
+export interface VerifyMFATotpProps {
+    mfaToken: string;
+    mfaLogin: any;
+    changeModule: any;
+}
+export declare const VerifyMFATotp: React.FC<VerifyMFATotpProps>;
+export interface MFATotpProps {
+    changeModule: any;
+    config: MFAConfig;
+    initData: GuardMFAInitData;
+    mfaLogin: any;
+}
+export declare const MFATotp: React.FC<MFATotpProps>;

package/types/MFA/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import './styles.less';
+interface MFABackStateContextType {
+    setMfaBackState: React.Dispatch<React.SetStateAction<string>>;
+    mfaBackState: string;
+}
+export declare const MFABackStateContext: React.Context<MFABackStateContextType | undefined>;
+export declare const GuardMFAView: React.FC;
+export {};

package/types/MFA/interface.d.ts

@@ -0,0 +1,40 @@
+import { IG2Config, IG2Events, IG2FCProps } from '../Type';
+import { AuthenticationClient, User } from 'authing-js-sdk';
+export interface MFAConfig extends IG2Config {
+    autoRegister: boolean;
+}
+export declare const getDefaultMFAConfig: () => MFAConfig;
+export interface MFAEvents extends IG2Events {
+    onLogin?: (user: User, authClient: AuthenticationClient) => void;
+}
+export declare enum MFAType {
+    SMS = "SMS",
+    EMAIL = "EMAIL",
+    TOTP = "OTP",
+    FACE = "FACE"
+}
+export interface GuardMFAInitData {
+    mfaToken: string;
+    applicationMfa: {
+        mfaPolicy: MFAType;
+        sort: number;
+        status: 0 | 1;
+    }[];
+    phoneCountryCode?: string;
+    faceMfaEnabled: boolean;
+    totpMfaEnabled: boolean;
+    email?: string;
+    phone?: string;
+    avatar?: string;
+    nickme?: string;
+    username?: string;
+    current?: MFAType;
+}
+export interface GuardMFAProps extends IG2FCProps, MFAEvents {
+    config: Partial<MFAConfig>;
+    initData: GuardMFAInitData;
+}
+export interface GuardMFAViewProps extends GuardMFAProps {
+    config: MFAConfig;
+    initData: GuardMFAInitData;
+}

package/types/MFA/mfaMethods/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { MFAType } from '../interface';
+import './style.less';
+export interface MFAMethodsProps {
+    method: MFAType;
+    onChangeMethod: (type: MFAType) => void;
+}
+export declare const MFAMethods: React.FC<MFAMethodsProps>;