amazon-cognito-identity-js

constructor(data: IAuthenticationDetailsData);

getPassword: () => string;

getUsername: () => string;

getValidationData: () => any[];

constructor({ AccessToken }: { AccessToken: string });

payload: { [key: string]: any };

decodePayload: () => { [id: string]: any };

getExpiration: () => number;

getIssuedAt: () => number;

getJwtToken: () => string;

constructor({ IdToken }: { IdToken: string });

payload: { [key: string]: any };

decodePayload: () => { [id: string]: any };

getExpiration: () => number;

getIssuedAt: () => number;

getJwtToken: () => string;

constructor({ RefreshToken }: { RefreshToken: string });

getToken: () => string;

constructor(data: ICognitoUserData);

challengeName?: ChallengeName;

associateSoftwareToken: (callbacks: {
    associateSecretCode: (secretCode: string) => void;
    onFailure: (err: any) => void;
}) => void;

authenticateUser: (
    authenticationDetails: AuthenticationDetails,
    callbacks: IAuthenticationCallback
) => void;

changePassword: (
    oldPassword: string,
    newPassword: string,
    callback: NodeCallback<Error, 'SUCCESS'>,
    clientMetadata?: ClientMetadata
) => void;

completeNewPasswordChallenge: (
    newPassword: string,
    requiredAttributeData: any,
    callbacks: IAuthenticationCallback,
    clientMetadata?: ClientMetadata
) => void;

confirmPassword: (
    verificationCode: string,
    newPassword: string,
    callbacks: {
        onSuccess: (success: string) => void;
        onFailure: (err: Error) => void;
    },
    clientMetaData?: ClientMetadata
) => void;

confirmRegistration: (
    code: string,
    forceAliasCreation: boolean,
    callback: NodeCallback<any, any>,
    clientMetadata?: ClientMetadata
) => void;

deleteAttributes: (
    attributeList: string[],
    callback: NodeCallback<Error, string>
) => void;

deleteUser: (callback: NodeCallback<Error, string>) => void;

disableMFA: (callback: NodeCallback<Error, string>) => void;

enableMFA: (callback: NodeCallback<Error, string>) => void;

forgetDevice: (callbacks: {
    onSuccess: (success: string) => void;
    onFailure: (err: Error) => void;
}) => void;

forgetSpecificDevice: (
    deviceKey: string,
    callbacks: {
        onSuccess: (success: string) => void;
        onFailure: (err: Error) => void;
    }
) => void;

forgotPassword: (
    callbacks: {
        onSuccess: (data: any) => void;
        onFailure: (err: Error) => void;
        inputVerificationCode?: (data: any) => void;
    },
    clientMetaData?: ClientMetadata
) => void;

getAttributeVerificationCode: (
    name: string,
    callback: {
        onSuccess: (success: string) => void;
        onFailure: (err: Error) => void;
        inputVerificationCode?: (data: string) => void | null;
    },
    clientMetadata?: ClientMetadata
) => void;

getAuthenticationFlowType: () => string;

getCachedDeviceKeyAndPassword: () => void;

getDevice: (callbacks: {
    onSuccess: (success: string) => void;
    onFailure: (err: Error) => void;
}) => any;

getMFAOptions: (callback: NodeCallback<Error, MFAOption[]>) => void;

getSession: (
    callback:
        | ((error: Error, session: null) => void)
        | ((error: null, session: CognitoUserSession) => void),
    options?: GetSessionOptions
) => void;

getSignInUserSession: () => CognitoUserSession | null;

getUserAttributes: (
    callback: NodeCallback<Error, CognitoUserAttribute[]>
) => void;

getUserData: (callback: NodeCallback<Error, UserData>, params?: any) => void;

getUsername: () => string;

globalSignOut: (callbacks: {
    onSuccess: (msg: string) => void;
    onFailure: (err: Error) => void;
}) => void;

initiateAuth: (
    authenticationDetails: AuthenticationDetails,
    callbacks: IAuthenticationCallback
) => void;

listDevices: (
    limit: number,
    paginationToken: string | null,
    callbacks: {
        onSuccess: (data: any) => void;
        onFailure: (err: Error) => void;
    }
) => void;

refreshSession: (
    refreshToken: CognitoRefreshToken,
    callback: NodeCallback<any, any>,
    clientMetadata?: ClientMetadata
) => void;

resendConfirmationCode: (
    callback: NodeCallback<Error, any>,
    clientMetaData?: ClientMetadata
) => void;

sendCustomChallengeAnswer: (
    answerChallenge: any,
    callback: IAuthenticationCallback,
    clientMetaData?: ClientMetadata
) => void;

sendMFACode: (
    confirmationCode: string,
    callbacks: {
        onSuccess: (
            session: CognitoUserSession,
            userConfirmationNecessary?: boolean
        ) => void;
        onFailure: (err: any) => void;
    },
    mfaType?: string,
    clientMetadata?: ClientMetadata
) => void;

sendMFASelectionAnswer: (
    answerChallenge: string,
    callbacks: {
        onSuccess: (session: CognitoUserSession) => void;
        onFailure: (err: any) => void;
        mfaRequired?: (
            challengeName: ChallengeName,
            challengeParameters: any
        ) => void;
        totpRequired?: (
            challengeName: ChallengeName,
            challengeParameters: any
        ) => void;
    }
) => void;

setAuthenticationFlowType: (authenticationFlowType: string) => string;

setDeviceStatusNotRemembered: (callbacks: {
    onSuccess: (success: string) => void;
    onFailure: (err: any) => void;
}) => void;

setDeviceStatusRemembered: (callbacks: {
    onSuccess: (success: string) => void;
    onFailure: (err: any) => void;
}) => void;

setSignInUserSession: (signInUserSession: CognitoUserSession) => void;

setUserMfaPreference: (
    smsMfaSettings: IMfaSettings | null,
    softwareTokenMfaSettings: IMfaSettings | null,
    callback: NodeCallback<Error, string>
) => void;

signOut: (callback?: () => void) => void;

updateAttributes: (
    attributes: (CognitoUserAttribute | ICognitoUserAttributeData)[],
    callback: UpdateAttributesNodeCallback<Error, string, any>,
    clientMetadata?: ClientMetadata
) => void;

verifyAttribute: (
    attributeName: string,
    confirmationCode: string,
    callbacks: {
        onSuccess: (success: string) => void;
        onFailure: (err: Error) => void;
    }
) => void;

verifySoftwareToken: (
    totpCode: string,
    friendlyDeviceName: string,
    callbacks: {
        onSuccess: (session: CognitoUserSession) => void;
        onFailure: (err: Error) => void;
    }
) => void;

constructor(data: ICognitoUserAttributeData);

Name: string;

Value: string;

getName: () => string;

getValue: () => string;

setName: (name: string) => CognitoUserAttribute;

setValue: (value: string) => CognitoUserAttribute;

toJSON: () => Object;

toString: () => string;

constructor(
    data: ICognitoUserPoolData,
    wrapRefreshSessionCallback?: (target: NodeCallback.Any) => NodeCallback.Any
);

getClientId: () => string;

getCurrentUser: () => CognitoUser | null;

getUserPoolId: () => string;

getUserPoolName: () => string;

signUp: (
    username: string,
    password: string,
    userAttributes: CognitoUserAttribute[],
    validationData: CognitoUserAttribute[],
    callback: NodeCallback<Error, ISignUpResult>,
    clientMetadata?: ClientMetadata
) => void;

constructor(data: ICognitoUserSessionData);

getAccessToken: () => CognitoAccessToken;

getIdToken: () => CognitoIdToken;

getRefreshToken: () => CognitoRefreshToken;

isValid: () => boolean;

constructor(data?: ICookieStorageData);

clear: () => void;

getItem: (key: string) => string;

removeItem: (key: string) => void;

setItem: (key: string, value: string) => void;

constructor();

constructor(words?: string[], sigBytes?: number);

random: (nBytes: number) => WordArray;

toString: () => string;

AttributeName: string;

DeliveryMedium: string;

Destination: string;

clientMetadata: Record<string, string>;

customChallenge?: (challengeParameters: any) => void;

mfaRequired?: (challengeName: ChallengeName, challengeParameters: any) => void;

mfaSetup?: (challengeName: ChallengeName, challengeParameters: any) => void;

newPasswordRequired?: (userAttributes: any, requiredAttributes: any) => void;

onFailure: (err: any) => void;

onSuccess: (
    session: CognitoUserSession,
    userConfirmationNecessary?: boolean
) => void;

selectMFAType?: (challengeName: ChallengeName, challengeParameters: any) => void;

totpRequired?: (challengeName: ChallengeName, challengeParameters: any) => void;

ClientMetadata?: ClientMetadata;

Password?: string;

Username: string;

ValidationData?: { [key: string]: any };

clear: () => void;

getItem: (key: string) => string | null;

removeItem: (key: string) => void;

setItem: (key: string, value: string) => void;

Name: string;

Value: string;

Pool: CognitoUserPool;

Storage?: ICognitoStorage;

Username: string;

AdvancedSecurityDataCollectionFlag?: boolean;

ClientId: string;

endpoint?: string;

Storage?: ICognitoStorage;

UserPoolId: string;

AccessToken: CognitoAccessToken;

IdToken: CognitoIdToken;

RefreshToken?: CognitoRefreshToken;

domain?: string;

expires?: number;

path?: string;

sameSite?: 'strict' | 'lax' | 'none';

secure?: boolean;

Enabled: boolean;

PreferredMfa: boolean;

codeDeliveryDetails: CodeDeliveryDetails;

user: CognitoUser;

userConfirmed: boolean;

userSub: string;

AttributeName: string;

DeliveryMedium: 'SMS' | 'EMAIL';

MFAOptions: MFAOption[];

PreferredMfaSetting: string;

UserAttributes: ICognitoUserAttributeData[];

UserMFASettingList: string[];

Username: string;