@liftric/cognito-idp/cognito-idp.d.ts

Lightweight AWS Cognito Identity Provider client.

type Nullable<T> = T | null | undefined
declare function KtSingleton<T>(): T & (abstract new() => any);
export declare namespace io.ktor.client.engine.js {
    /** @deprecated  */
    const initHook: any;
}
export declare namespace com.liftric.cognito.idp.core {
    class UserAttribute {
        constructor(Name: string, Value: string);
        get Name(): string;
        get Value(): string;
        copy(Name?: string, Value?: string): com.liftric.cognito.idp.core.UserAttribute;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace UserAttribute.$metadata$ {
        const constructor: abstract new () => UserAttribute;
    }
    namespace UserAttribute {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class MfaSettings {
        constructor(Enabled: boolean, PreferredMfa: boolean);
        get Enabled(): boolean;
        get PreferredMfa(): boolean;
        copy(Enabled?: boolean, PreferredMfa?: boolean): com.liftric.cognito.idp.core.MfaSettings;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace MfaSettings.$metadata$ {
        const constructor: abstract new () => MfaSettings;
    }
    namespace MfaSettings {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
}
export declare namespace com.liftric.cognito.idp.core {
    class AuthenticationResult {
        constructor(AccessToken: Nullable<string>, ExpiresIn: Nullable<number>, IdToken: Nullable<string>, RefreshToken: Nullable<string>, TokenType: Nullable<string>, NewDeviceMetadata: Nullable<com.liftric.cognito.idp.core.NewDeviceMetadata>);
        get AccessToken(): Nullable<string>;
        get ExpiresIn(): Nullable<number>;
        get IdToken(): Nullable<string>;
        get RefreshToken(): Nullable<string>;
        get TokenType(): Nullable<string>;
        get NewDeviceMetadata(): Nullable<com.liftric.cognito.idp.core.NewDeviceMetadata>;
        copy(AccessToken?: Nullable<string>, ExpiresIn?: Nullable<number>, IdToken?: Nullable<string>, RefreshToken?: Nullable<string>, TokenType?: Nullable<string>, NewDeviceMetadata?: Nullable<com.liftric.cognito.idp.core.NewDeviceMetadata>): com.liftric.cognito.idp.core.AuthenticationResult;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace AuthenticationResult.$metadata$ {
        const constructor: abstract new () => AuthenticationResult;
    }
    namespace AuthenticationResult {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class NewDeviceMetadata {
        constructor(DeviceGroupKey: Nullable<string>, DeviceKey: Nullable<string>);
        get DeviceGroupKey(): Nullable<string>;
        get DeviceKey(): Nullable<string>;
        copy(DeviceGroupKey?: Nullable<string>, DeviceKey?: Nullable<string>): com.liftric.cognito.idp.core.NewDeviceMetadata;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace NewDeviceMetadata.$metadata$ {
        const constructor: abstract new () => NewDeviceMetadata;
    }
    namespace NewDeviceMetadata {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class SignUpResponse {
        constructor(CodeDeliveryDetails: Nullable<com.liftric.cognito.idp.core.CodeDeliveryDetails>, UserConfirmed: boolean, UserSub: string);
        get CodeDeliveryDetails(): Nullable<com.liftric.cognito.idp.core.CodeDeliveryDetails>;
        get UserConfirmed(): boolean;
        get UserSub(): string;
        copy(CodeDeliveryDetails?: Nullable<com.liftric.cognito.idp.core.CodeDeliveryDetails>, UserConfirmed?: boolean, UserSub?: string): com.liftric.cognito.idp.core.SignUpResponse;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace SignUpResponse.$metadata$ {
        const constructor: abstract new () => SignUpResponse;
    }
    namespace SignUpResponse {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class ResendConfirmationCodeResponse {
        constructor(CodeDeliveryDetails: com.liftric.cognito.idp.core.CodeDeliveryDetails);
        get CodeDeliveryDetails(): com.liftric.cognito.idp.core.CodeDeliveryDetails;
        copy(CodeDeliveryDetails?: com.liftric.cognito.idp.core.CodeDeliveryDetails): com.liftric.cognito.idp.core.ResendConfirmationCodeResponse;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace ResendConfirmationCodeResponse.$metadata$ {
        const constructor: abstract new () => ResendConfirmationCodeResponse;
    }
    namespace ResendConfirmationCodeResponse {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class CodeDeliveryDetails {
        constructor(AttributeName: Nullable<string>, DeliveryMedium: Nullable<string>, Destination: Nullable<string>);
        get AttributeName(): Nullable<string>;
        get DeliveryMedium(): Nullable<string>;
        get Destination(): Nullable<string>;
        copy(AttributeName?: Nullable<string>, DeliveryMedium?: Nullable<string>, Destination?: Nullable<string>): com.liftric.cognito.idp.core.CodeDeliveryDetails;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace CodeDeliveryDetails.$metadata$ {
        const constructor: abstract new () => CodeDeliveryDetails;
    }
    namespace CodeDeliveryDetails {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class MFAOptions {
        constructor(AttributeName: Nullable<string>, DeliveryMedium: Nullable<string>);
        get AttributeName(): Nullable<string>;
        get DeliveryMedium(): Nullable<string>;
        copy(AttributeName?: Nullable<string>, DeliveryMedium?: Nullable<string>): com.liftric.cognito.idp.core.MFAOptions;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace MFAOptions.$metadata$ {
        const constructor: abstract new () => MFAOptions;
    }
    namespace MFAOptions {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class GetAttributeVerificationCodeResponse {
        constructor(CodeDeliveryDetails: com.liftric.cognito.idp.core.CodeDeliveryDetails);
        get CodeDeliveryDetails(): com.liftric.cognito.idp.core.CodeDeliveryDetails;
        copy(CodeDeliveryDetails?: com.liftric.cognito.idp.core.CodeDeliveryDetails): com.liftric.cognito.idp.core.GetAttributeVerificationCodeResponse;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace GetAttributeVerificationCodeResponse.$metadata$ {
        const constructor: abstract new () => GetAttributeVerificationCodeResponse;
    }
    namespace GetAttributeVerificationCodeResponse {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class ForgotPasswordResponse {
        constructor(CodeDeliveryDetails: com.liftric.cognito.idp.core.CodeDeliveryDetails);
        get CodeDeliveryDetails(): com.liftric.cognito.idp.core.CodeDeliveryDetails;
        copy(CodeDeliveryDetails?: com.liftric.cognito.idp.core.CodeDeliveryDetails): com.liftric.cognito.idp.core.ForgotPasswordResponse;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace ForgotPasswordResponse.$metadata$ {
        const constructor: abstract new () => ForgotPasswordResponse;
    }
    namespace ForgotPasswordResponse {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class AssociateSoftwareTokenResponse {
        constructor(SecretCode: string, Session: Nullable<string>);
        get SecretCode(): string;
        get Session(): Nullable<string>;
        copy(SecretCode?: string, Session?: Nullable<string>): com.liftric.cognito.idp.core.AssociateSoftwareTokenResponse;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace AssociateSoftwareTokenResponse.$metadata$ {
        const constructor: abstract new () => AssociateSoftwareTokenResponse;
    }
    namespace AssociateSoftwareTokenResponse {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
    class VerifySoftwareTokenResponse {
        constructor(Session: Nullable<string>, Status: string);
        get Session(): Nullable<string>;
        get Status(): string;
        copy(Session?: Nullable<string>, Status?: string): com.liftric.cognito.idp.core.VerifySoftwareTokenResponse;
        toString(): string;
        hashCode(): number;
        equals(other: Nullable<any>): boolean;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace VerifySoftwareTokenResponse.$metadata$ {
        const constructor: abstract new () => VerifySoftwareTokenResponse;
    }
    namespace VerifySoftwareTokenResponse {
        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
            private constructor();
        }
        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
        namespace Companion.$metadata$ {
            abstract class constructor {
                private constructor();
            }
        }
    }
}
export declare abstract class IdentityProviderExceptionJs extends /* kotlin.Exception */ Error {
    protected constructor(status: number, message: Nullable<string>);
    get status(): number;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IdentityProviderExceptionJs.$metadata$ {
    const constructor: abstract new () => IdentityProviderExceptionJs;
}
export declare namespace IdentityProviderExceptionJs {
    class CodeMismatch extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace CodeMismatch.$metadata$ {
        const constructor: abstract new () => CodeMismatch;
    }
    class ConcurrentModification extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace ConcurrentModification.$metadata$ {
        const constructor: abstract new () => ConcurrentModification;
    }
    class EnableSoftwareTokenMFA extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace EnableSoftwareTokenMFA.$metadata$ {
        const constructor: abstract new () => EnableSoftwareTokenMFA;
    }
    class ExpiredCode extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace ExpiredCode.$metadata$ {
        const constructor: abstract new () => ExpiredCode;
    }
    class InternalError extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace InternalError.$metadata$ {
        const constructor: abstract new () => InternalError;
    }
    class InvalidLambdaResponse extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace InvalidLambdaResponse.$metadata$ {
        const constructor: abstract new () => InvalidLambdaResponse;
    }
    class InvalidParameter extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace InvalidParameter.$metadata$ {
        const constructor: abstract new () => InvalidParameter;
    }
    class InvalidPassword extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace InvalidPassword.$metadata$ {
        const constructor: abstract new () => InvalidPassword;
    }
    class InvalidUserPoolConfiguration extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace InvalidUserPoolConfiguration.$metadata$ {
        const constructor: abstract new () => InvalidUserPoolConfiguration;
    }
    class LimitExceeded extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace LimitExceeded.$metadata$ {
        const constructor: abstract new () => LimitExceeded;
    }
    class NotAuthorized extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace NotAuthorized.$metadata$ {
        const constructor: abstract new () => NotAuthorized;
    }
    class PasswordResetRequired extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace PasswordResetRequired.$metadata$ {
        const constructor: abstract new () => PasswordResetRequired;
    }
    class ResourceNotFound extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace ResourceNotFound.$metadata$ {
        const constructor: abstract new () => ResourceNotFound;
    }
    class SoftwareTokenMFANotFound extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace SoftwareTokenMFANotFound.$metadata$ {
        const constructor: abstract new () => SoftwareTokenMFANotFound;
    }
    class TooManyFailedAttempts extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace TooManyFailedAttempts.$metadata$ {
        const constructor: abstract new () => TooManyFailedAttempts;
    }
    class TooManyRequests extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace TooManyRequests.$metadata$ {
        const constructor: abstract new () => TooManyRequests;
    }
    class UnexpectedLambda extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace UnexpectedLambda.$metadata$ {
        const constructor: abstract new () => UnexpectedLambda;
    }
    class UserLambdaValidation extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace UserLambdaValidation.$metadata$ {
        const constructor: abstract new () => UserLambdaValidation;
    }
    class UserNotConfirmed extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace UserNotConfirmed.$metadata$ {
        const constructor: abstract new () => UserNotConfirmed;
    }
    class UserNotFound extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, message: Nullable<string>);
        get status(): number;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace UserNotFound.$metadata$ {
        const constructor: abstract new () => UserNotFound;
    }
    class Unknown extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(status: number, type: string, message: Nullable<string>);
        get status(): number;
        get type(): string;
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Unknown.$metadata$ {
        const constructor: abstract new () => Unknown;
    }
    class NonCognitoException extends IdentityProviderExceptionJs.$metadata$.constructor {
        constructor(cause: Nullable<Error>, message?: Nullable<string>);
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace NonCognitoException.$metadata$ {
        const constructor: abstract new () => NonCognitoException;
    }
}
export declare class IdentityProviderClientJS {
    constructor(region: string, clientId: string);
    signUp(username: string, password: string, attributes?: Nullable<Array<com.liftric.cognito.idp.core.UserAttribute>>, clientMetadata?: Nullable<Array<MapEntry>>): Promise<com.liftric.cognito.idp.core.SignUpResponse>;
    confirmSignUp(username: string, confirmationCode: string): Promise<void>;
    resendConfirmationCode(username: string): Promise<com.liftric.cognito.idp.core.ResendConfirmationCodeResponse>;
    signIn(username: string, password: string): Promise<SignInResponseJS>;
    refresh(refreshToken: string): Promise<SignInResponseJS>;
    getUser(accessToken: string): Promise<GetUserResponseJS>;
    updateUserAttributes(accessToken: string, attributes: Array<com.liftric.cognito.idp.core.UserAttribute>): Promise<UpdateUserAttributesResponseJS>;
    changePassword(accessToken: string, currentPassword: string, newPassword: string): Promise<void>;
    forgotPassword(username: string, clientMetadata?: Nullable<Array<MapEntry>>): Promise<com.liftric.cognito.idp.core.ForgotPasswordResponse>;
    confirmForgotPassword(confirmationCode: string, username: string, password: string): Promise<void>;
    getUserAttributeVerificationCode(accessToken: string, attributeName: string, clientMetadata?: Nullable<Array<MapEntry>>): Promise<com.liftric.cognito.idp.core.GetAttributeVerificationCodeResponse>;
    verifyUserAttribute(accessToken: string, attributeName: string, code: string): Promise<void>;
    signOut(accessToken: string): Promise<void>;
    revokeToken(refreshToken: string): Promise<void>;
    deleteUser(accessToken: string): Promise<void>;
    setUserMFAPreference(accessToken: string, smsMfaSettings: Nullable<com.liftric.cognito.idp.core.MfaSettings>, softwareTokenMfaSettings: Nullable<com.liftric.cognito.idp.core.MfaSettings>): Promise<void>;
    respondToAuthChallenge(challengeName: string, challengeResponses: Array<MapEntry>, session: string): Promise<SignInResponseJS>;
    associateSoftwareToken(accessToken: string): Promise<com.liftric.cognito.idp.core.AssociateSoftwareTokenResponse>;
    associateSoftwareTokenBySession(session: string): Promise<com.liftric.cognito.idp.core.AssociateSoftwareTokenResponse>;
    verifySoftwareToken(accessToken: string, friendlyDeviceName: Nullable<string>, userCode: string): Promise<com.liftric.cognito.idp.core.VerifySoftwareTokenResponse>;
    verifySoftwareTokenBySession(session: string, friendlyDeviceName: Nullable<string>, userCode: string): Promise<com.liftric.cognito.idp.core.VerifySoftwareTokenResponse>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace IdentityProviderClientJS.$metadata$ {
    const constructor: abstract new () => IdentityProviderClientJS;
}
export declare class SignInResponseJS {
    constructor(AuthenticationResult: Nullable<com.liftric.cognito.idp.core.AuthenticationResult>, ChallengeParameters: Array<MapEntry>, ChallengeName: Nullable<string>, Session: Nullable<string>);
    get AuthenticationResult(): Nullable<com.liftric.cognito.idp.core.AuthenticationResult>;
    get ChallengeParameters(): Array<MapEntry>;
    get ChallengeName(): Nullable<string>;
    get Session(): Nullable<string>;
    equals(other: Nullable<any>): boolean;
    hashCode(): number;
    copy(AuthenticationResult?: Nullable<com.liftric.cognito.idp.core.AuthenticationResult>, ChallengeParameters?: Array<MapEntry>, ChallengeName?: Nullable<string>, Session?: Nullable<string>): SignInResponseJS;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace SignInResponseJS.$metadata$ {
    const constructor: abstract new () => SignInResponseJS;
}
export declare class GetUserResponseJS {
    constructor(MFAOptions: Nullable<com.liftric.cognito.idp.core.MFAOptions>, PreferredMfaSetting: Nullable<string>, UserAttributes: Array<com.liftric.cognito.idp.core.UserAttribute>, UserMFASettingList: Array<string>, Username: string);
    get MFAOptions(): Nullable<com.liftric.cognito.idp.core.MFAOptions>;
    get PreferredMfaSetting(): Nullable<string>;
    get UserAttributes(): Array<com.liftric.cognito.idp.core.UserAttribute>;
    get UserMFASettingList(): Array<string>;
    get Username(): string;
    equals(other: Nullable<any>): boolean;
    hashCode(): number;
    copy(MFAOptions?: Nullable<com.liftric.cognito.idp.core.MFAOptions>, PreferredMfaSetting?: Nullable<string>, UserAttributes?: Array<com.liftric.cognito.idp.core.UserAttribute>, UserMFASettingList?: Array<string>, Username?: string): GetUserResponseJS;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace GetUserResponseJS.$metadata$ {
    const constructor: abstract new () => GetUserResponseJS;
}
export declare class UpdateUserAttributesResponseJS {
    constructor(CodeDeliveryDetailsList?: Array<com.liftric.cognito.idp.core.CodeDeliveryDetails>);
    get CodeDeliveryDetailsList(): Array<com.liftric.cognito.idp.core.CodeDeliveryDetails>;
    equals(other: Nullable<any>): boolean;
    hashCode(): number;
    copy(CodeDeliveryDetailsList?: Array<com.liftric.cognito.idp.core.CodeDeliveryDetails>): UpdateUserAttributesResponseJS;
    toString(): string;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace UpdateUserAttributesResponseJS.$metadata$ {
    const constructor: abstract new () => UpdateUserAttributesResponseJS;
}
export declare class MapEntry {
    constructor(key: string, value: string);
    get key(): string;
    get value(): string;
    copy(key?: string, value?: string): MapEntry;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace MapEntry.$metadata$ {
    const constructor: abstract new () => MapEntry;
}
export as namespace com_liftric_cognito_idp;