@okta/okta-auth-js 6.9.0 → 7.0.0

package/types/lib/idx/remediators/SelectAuthenticatorUnlockAccount.d.ts

@@ -0,0 +1,36 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { SelectAuthenticator, SelectAuthenticatorValues } from './Base/SelectAuthenticator';
+import { Authenticator } from '../types';
+import { IdxRemediationValue } from '../types/idx-js';
+export declare type SelectAuthenticatorUnlockAccountValues = SelectAuthenticatorValues & {
+    identifier?: string;
+    methodType?: string;
+};
+export declare class SelectAuthenticatorUnlockAccount extends SelectAuthenticator<SelectAuthenticatorUnlockAccountValues> {
+    static remediationName: string;
+    authenticator?: Authenticator;
+    map: {
+        identifier: string[];
+    };
+    canRemediate(): boolean;
+    mapAuthenticator(remediationValue: IdxRemediationValue): Authenticator | {
+        id: any;
+    } | {
+        methodType: string;
+        id: any;
+    };
+    getInputUsername(): {
+        name: string;
+        type: string;
+    };
+}

package/types/lib/idx/remediators/SelectEnrollmentChannel.d.ts

@@ -0,0 +1,46 @@
+/*!
+ * Copyright (c) 2021-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { Remediator, RemediationValues } from './Base/Remediator';
+import { IdxRemediationValueForm, IdxContext } from '../types/idx-js';
+import { OktaAuthIdxInterface } from '../types/api';
+export declare type SelectEnrollmentChannelValues = RemediationValues & {
+    channel?: string;
+};
+export declare class SelectEnrollmentChannel extends Remediator<SelectEnrollmentChannelValues> {
+    static remediationName: string;
+    canRemediate(): boolean;
+    getNextStep(authClient: OktaAuthIdxInterface, context: IdxContext): {
+        authenticator: import("../types/idx-js").IdxAuthenticator;
+        name: string;
+        canSkip?: boolean | undefined;
+        canResend?: boolean | undefined;
+        inputs?: import("../types/api").Input[] | undefined;
+        poll?: import("../types/api").IdxPollOptions | undefined;
+        authenticatorEnrollments?: import("../types/idx-js").IdxAuthenticator[] | undefined;
+        action?: ((params?: import("../types/idx-js").IdxActionParams | undefined) => Promise<import("../types/api").IdxTransaction>) | undefined;
+        idp?: import("../types/idx-js").IdpConfig | undefined;
+        href?: string | undefined;
+        relatesTo?: {
+            type?: string | undefined;
+            value: import("../types/idx-js").IdxAuthenticator;
+        } | undefined;
+        refresh?: number | undefined;
+    };
+    getData(): {
+        authenticator: {
+            id: string | IdxRemediationValueForm | undefined;
+            channel: string | undefined;
+        };
+        stateHandle: string | undefined;
+    };
+    getValuesAfterProceed(): SelectEnrollmentChannelValues;
+}

package/types/lib/idx/run.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { OktaAuthIdxInterface, IdxTransaction, RunOptions } from './types';
+export declare function run(authClient: OktaAuthIdxInterface, options?: RunOptions): Promise<IdxTransaction>;

package/types/lib/idx/startTransaction.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { OktaAuthIdxInterface, IdxTransaction, StartOptions } from './types';
+export declare function startTransaction(authClient: OktaAuthIdxInterface, options?: StartOptions): Promise<IdxTransaction>;

package/types/lib/idx/storage.d.ts

@@ -0,0 +1,18 @@
+import { CookieOptions, StorageManagerOptions, StorageOptions, StorageUtil } from '../storage/types';
+import { IdxTransactionMeta } from './types';
+import { IdxResponseStorage } from './types/storage';
+export declare function createIdxStorageManager<M extends IdxTransactionMeta>(): {
+    new (storageManagerOptions: StorageManagerOptions, cookieOptions: CookieOptions, storageUtil: StorageUtil): {
+        getIdxResponseStorage(options?: StorageOptions): IdxResponseStorage | null;
+        getTransactionStorage(options?: StorageOptions | undefined): import("../oidc").TransactionStorage<M>;
+        getSharedTansactionStorage(options?: StorageOptions | undefined): import("../oidc").TransactionStorage<M>;
+        getOriginalUriStorage(options?: StorageOptions | undefined): import("../oidc").TransactionStorage<M>;
+        storageManagerOptions: StorageManagerOptions;
+        cookieOptions: CookieOptions;
+        storageUtil: StorageUtil;
+        getOptionsForSection(sectionName: string, overrideOptions?: StorageOptions | undefined): StorageOptions;
+        getStorage(options: StorageOptions): import("../storage").SimpleStorage;
+        getTokenStorage(options?: StorageOptions | undefined): import("../storage").StorageProvider;
+        getHttpCache(options?: StorageOptions | undefined): import("../storage").StorageProvider;
+    };
+};

package/types/lib/idx/transactionMeta.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright (c) 2021, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { OktaAuthIdxInterface, IdxTransactionMeta, IdxTransactionMetaOptions } from './types';
+export declare function createTransactionMeta(authClient: OktaAuthIdxInterface, options?: IdxTransactionMetaOptions): Promise<IdxTransactionMeta>;
+export declare function hasSavedInteractionHandle(authClient: OktaAuthIdxInterface, options?: IdxTransactionMetaOptions): boolean;
+export declare function getSavedTransactionMeta(authClient: OktaAuthIdxInterface, options?: IdxTransactionMetaOptions): IdxTransactionMeta | undefined;
+export declare function getTransactionMeta(authClient: OktaAuthIdxInterface, options?: IdxTransactionMetaOptions): Promise<IdxTransactionMeta>;
+export declare function saveTransactionMeta(authClient: OktaAuthIdxInterface, meta: any): void;
+export declare function clearTransactionMeta(authClient: OktaAuthIdxInterface): void;
+export declare function isTransactionMetaValid(meta: any, options?: IdxTransactionMetaOptions): boolean;
+export declare function isTransactionMetaValidForFlow(meta: any, flow: any): boolean;
+export declare function isTransactionMetaValidForOptions(meta: any, options: any, keys: any): boolean;

package/types/lib/idx/types/api.d.ts

@@ -0,0 +1,158 @@
+/*!
+ * Copyright (c) 2021-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { APIError } from '../../errors/types';
+import { OktaAuthOAuthInterface, Tokens, TransactionManagerConstructor, TransactionManagerInterface } from '../../oidc/types';
+import { FlowIdentifier } from './FlowIdentifier';
+import { IdxActions, IdxAuthenticator, IdxContext, IdxForm, IdxMessage, IdxOption, IdxRemediation, IdxResponse, RawIdxResponse, IdxActionParams, IdpConfig, IdxToPersist } from './idx-js';
+import { AccountUnlockOptions, AuthenticationOptions, CancelOptions, InteractOptions, IntrospectOptions, OktaAuthIdxOptions, PasswordRecoveryOptions, ProceedOptions, RegistrationOptions, StartOptions, IdxTransactionMetaOptions } from './options';
+import { IdxTransactionMeta } from './meta';
+import { IdxStorageManagerInterface, SavedIdxResponse } from './storage';
+export declare enum IdxStatus {
+    SUCCESS = "SUCCESS",
+    PENDING = "PENDING",
+    FAILURE = "FAILURE",
+    TERMINAL = "TERMINAL",
+    CANCELED = "CANCELED"
+}
+export declare enum AuthenticatorKey {
+    OKTA_PASSWORD = "okta_password",
+    OKTA_EMAIL = "okta_email",
+    PHONE_NUMBER = "phone_number",
+    GOOGLE_AUTHENTICATOR = "google_otp",
+    SECURITY_QUESTION = "security_question",
+    OKTA_VERIFY = "okta_verify",
+    WEBAUTHN = "webauthn"
+}
+export declare type Input = {
+    name: string;
+    key?: string;
+    type?: string;
+    label?: string;
+    value?: string | {
+        form: IdxForm;
+    } | Input[];
+    minLength?: number;
+    maxLength?: number;
+    secret?: boolean;
+    required?: boolean;
+    options?: IdxOption[];
+    mutable?: boolean;
+    visible?: boolean;
+};
+export interface IdxPollOptions {
+    required?: boolean;
+    refresh?: number;
+}
+export declare type NextStep = {
+    name: string;
+    authenticator?: IdxAuthenticator;
+    canSkip?: boolean;
+    canResend?: boolean;
+    inputs?: Input[];
+    poll?: IdxPollOptions;
+    authenticatorEnrollments?: IdxAuthenticator[];
+    action?: (params?: IdxActionParams) => Promise<IdxTransaction>;
+    idp?: IdpConfig;
+    href?: string;
+    relatesTo?: {
+        type?: string;
+        value: IdxAuthenticator;
+    };
+    refresh?: number;
+};
+export declare enum IdxFeature {
+    PASSWORD_RECOVERY = "recover-password",
+    REGISTRATION = "enroll-profile",
+    SOCIAL_IDP = "redirect-idp",
+    ACCOUNT_UNLOCK = "unlock-account"
+}
+export interface IdxTransaction {
+    status: IdxStatus;
+    tokens?: Tokens;
+    nextStep?: NextStep;
+    messages?: IdxMessage[];
+    error?: APIError | IdxResponse;
+    meta?: IdxTransactionMeta;
+    enabledFeatures?: IdxFeature[];
+    availableSteps?: NextStep[];
+    requestDidSucceed?: boolean;
+    stepUp?: boolean;
+    proceed: (remediationName: string, params: unknown) => Promise<IdxResponse>;
+    neededToProceed: IdxRemediation[];
+    rawIdxState: RawIdxResponse;
+    interactionCode?: string;
+    actions: IdxActions;
+    context: IdxContext;
+}
+export declare type Authenticator = {
+    id?: string;
+    key?: string;
+    methodType?: string;
+    phoneNumber?: string;
+    channel?: string;
+};
+export declare function isAuthenticator(obj: any): obj is Authenticator;
+export interface RemediationResponse {
+    idxResponse: IdxResponse;
+    nextStep?: NextStep;
+    messages?: IdxMessage[];
+    terminal?: boolean;
+    canceled?: boolean;
+}
+export interface InteractResponse {
+    state?: string;
+    interactionHandle: string;
+    meta: IdxTransactionMeta;
+}
+export interface EmailVerifyCallbackResponse {
+    state: string;
+    otp: string;
+}
+export interface IdxAPI {
+    interact: (options?: InteractOptions) => Promise<InteractResponse>;
+    introspect: (options?: IntrospectOptions) => Promise<IdxResponse>;
+    makeIdxResponse: (rawIdxResponse: RawIdxResponse, toPersist: IdxToPersist, requestDidSucceed: boolean) => IdxResponse;
+    authenticate: (options?: AuthenticationOptions) => Promise<IdxTransaction>;
+    register: (options?: RegistrationOptions) => Promise<IdxTransaction>;
+    recoverPassword: (options?: PasswordRecoveryOptions) => Promise<IdxTransaction>;
+    unlockAccount: (options?: AccountUnlockOptions) => Promise<IdxTransaction>;
+    poll: (options?: IdxPollOptions) => Promise<IdxTransaction>;
+    start: (options?: StartOptions) => Promise<IdxTransaction>;
+    canProceed(options?: ProceedOptions): boolean;
+    proceed: (options?: ProceedOptions) => Promise<IdxTransaction>;
+    cancel: (options?: CancelOptions) => Promise<IdxTransaction>;
+    getFlow(): FlowIdentifier | undefined;
+    setFlow(flow: FlowIdentifier): void;
+    startTransaction: (options?: StartOptions) => Promise<IdxTransaction>;
+    isInteractionRequired: (hashOrSearch?: string) => boolean;
+    isInteractionRequiredError: (error: Error) => boolean;
+    handleInteractionCodeRedirect: (url: string) => Promise<void>;
+    isEmailVerifyCallback: (search: string) => boolean;
+    parseEmailVerifyCallback: (search: string) => EmailVerifyCallbackResponse;
+    handleEmailVerifyCallback: (search: string) => Promise<IdxTransaction | undefined>;
+    isEmailVerifyCallbackError: (error: Error) => boolean;
+    getSavedTransactionMeta: (options?: IdxTransactionMetaOptions) => IdxTransactionMeta | undefined;
+    createTransactionMeta: (options?: IdxTransactionMetaOptions) => Promise<IdxTransactionMeta>;
+    getTransactionMeta: (options?: IdxTransactionMetaOptions) => Promise<IdxTransactionMeta>;
+    saveTransactionMeta: (meta: unknown) => void;
+    clearTransactionMeta: () => void;
+    isTransactionMetaValid: (meta: unknown) => boolean;
+}
+export interface IdxTransactionManagerInterface extends TransactionManagerInterface {
+    saveIdxResponse(data: SavedIdxResponse): void;
+    loadIdxResponse(options?: IntrospectOptions): SavedIdxResponse | null;
+    clearIdxResponse(): void;
+}
+export declare type IdxTransactionManagerConstructor = TransactionManagerConstructor<IdxTransactionManagerInterface>;
+export interface OktaAuthIdxInterface<M extends IdxTransactionMeta = IdxTransactionMeta, S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>, O extends OktaAuthIdxOptions = OktaAuthIdxOptions, TM extends IdxTransactionManagerInterface = IdxTransactionManagerInterface> extends OktaAuthOAuthInterface<M, S, O, TM> {
+    idx: IdxAPI;
+}

package/types/lib/idx/types/index.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+export * from './api';
+export * from './options';
+export type { IdxMessage, IdxMessages, ChallengeData, ActivationData, IdxResponse, IdxContext, RawIdxResponse, IdxRemediation, IdxAuthenticator, IdxActionParams, } from './idx-js';
+export * from './meta';
+export type { FlowIdentifier } from './FlowIdentifier';
+export type { WebauthnEnrollValues } from '../authenticator/WebauthnEnrollment';
+export type { WebauthnVerificationValues } from '../authenticator/WebauthnVerification';
+export * from './storage';

package/types/lib/idx/types/meta.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * Copyright (c) 2021-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { PKCETransactionMeta } from '../../oidc/types/meta';
+import { FlowIdentifier } from './FlowIdentifier';
+export interface IdxTransactionMeta extends PKCETransactionMeta {
+    interactionHandle?: string;
+    remediations?: string[];
+    flow?: FlowIdentifier;
+    withCredentials?: boolean;
+    activationToken?: string;
+    recoveryToken?: string;
+    maxAge?: string | number;
+}

package/types/lib/idx/types/options.d.ts

@@ -0,0 +1,67 @@
+/*!
+ * Copyright (c) 2021-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { RemediationFlow } from '../flow';
+import { RemediateAction } from '../remediate';
+import { FlowIdentifier } from './FlowIdentifier';
+import { AuthenticatorVerificationDataValues, EnrollProfileValues, ResetAuthenticatorValues, SelectAuthenticatorUnlockAccountValues, SkipValues, EnrollPollValues as EnrollPollOptions, SelectEnrollmentChannelValues as SelectEnrollmentChannelOptions, IdentifyValues, SelectAuthenticatorAuthenticateValues, ChallengeAuthenticatorValues, ReEnrollAuthenticatorValues, AuthenticatorEnrollmentDataValues, SelectAuthenticatorEnrollValues, EnrollAuthenticatorValues } from '../remediators';
+import { IdxTransactionMeta } from './meta';
+import { OktaAuthCoreOptions } from '../../core/types';
+import { TransactionMetaOptions } from '../../oidc/types';
+import { OktaAuthOptionsConstructor } from '../../base/types';
+export interface IdxOptions {
+    flow?: FlowIdentifier;
+    exchangeCodeForTokens?: boolean;
+    autoRemediate?: boolean;
+    step?: string;
+    withCredentials?: boolean;
+}
+export interface InteractOptions extends IdxOptions {
+    state?: string;
+    scopes?: string[];
+    codeChallenge?: string;
+    codeChallengeMethod?: string;
+    activationToken?: string;
+    recoveryToken?: string;
+    clientSecret?: string;
+    maxAge?: string | number;
+    nonce?: string;
+}
+export interface IntrospectOptions extends IdxOptions {
+    interactionHandle?: string;
+    stateHandle?: string;
+    version?: string;
+}
+export interface RemediateOptions extends IdxOptions {
+    remediators?: RemediationFlow;
+    actions?: RemediateAction[];
+    useGenericRemediator?: boolean;
+}
+export interface RunOptions extends RemediateOptions, InteractOptions, IntrospectOptions {
+}
+export interface AuthenticationOptions extends RunOptions, IdentifyValues, SelectAuthenticatorAuthenticateValues, SelectAuthenticatorEnrollValues, ChallengeAuthenticatorValues, ReEnrollAuthenticatorValues, AuthenticatorEnrollmentDataValues, EnrollAuthenticatorValues {
+}
+export interface RegistrationOptions extends RunOptions, IdentifyValues, EnrollProfileValues, SelectAuthenticatorEnrollValues, EnrollAuthenticatorValues, AuthenticatorEnrollmentDataValues, SkipValues {
+}
+export interface PasswordRecoveryOptions extends RunOptions, IdentifyValues, SelectAuthenticatorAuthenticateValues, ChallengeAuthenticatorValues, ResetAuthenticatorValues, AuthenticatorVerificationDataValues, ReEnrollAuthenticatorValues {
+}
+export interface AccountUnlockOptions extends RunOptions, IdentifyValues, SelectAuthenticatorUnlockAccountValues, SelectAuthenticatorAuthenticateValues, ChallengeAuthenticatorValues, AuthenticatorVerificationDataValues {
+}
+export interface ProceedOptions extends AuthenticationOptions, RegistrationOptions, PasswordRecoveryOptions, AccountUnlockOptions, EnrollPollOptions, SelectEnrollmentChannelOptions {
+}
+export declare type CancelOptions = IdxOptions;
+export declare type StartOptions = RunOptions;
+export interface IdxTransactionMetaOptions extends TransactionMetaOptions, Pick<IdxTransactionMeta, 'state' | 'codeChallenge' | 'codeChallengeMethod' | 'codeVerifier' | 'flow' | 'activationToken' | 'recoveryToken'> {
+}
+export interface OktaAuthIdxOptions extends OktaAuthCoreOptions, Pick<IdxTransactionMeta, 'flow' | 'activationToken' | 'recoveryToken'> {
+    idx?: Pick<RunOptions, 'useGenericRemediator' | 'exchangeCodeForTokens'>;
+}
+export declare type OktaAuthIdxOptionsConstructor = OktaAuthOptionsConstructor<OktaAuthIdxOptions>;

package/types/lib/idx/types/storage.d.ts

@@ -0,0 +1,28 @@
+/*!
+ * Copyright (c) 2021-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { OAuthStorageManagerInterface } from '../../oidc/types/storage';
+import { StorageManagerConstructor, StorageOptions, StorageProvider } from '../../storage/types';
+import { RawIdxResponse } from './idx-js';
+import { IdxTransactionMeta } from './meta';
+import { IntrospectOptions } from './options';
+export interface SavedIdxResponse extends Pick<IntrospectOptions, 'stateHandle' | 'interactionHandle'> {
+    rawIdxResponse: RawIdxResponse;
+    requestDidSucceed?: boolean;
+}
+export interface IdxResponseStorage extends StorageProvider {
+    setStorage(obj: SavedIdxResponse): void;
+    getStorage(): SavedIdxResponse;
+}
+export interface IdxStorageManagerInterface<M extends IdxTransactionMeta = IdxTransactionMeta> extends OAuthStorageManagerInterface<M> {
+    getIdxResponseStorage(options?: StorageOptions): IdxResponseStorage | null;
+}
+export declare type IdxStorageManagerConstructor<M extends IdxTransactionMeta = IdxTransactionMeta> = StorageManagerConstructor<IdxStorageManagerInterface<M>>;

package/types/lib/idx/unlockAccount.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { OktaAuthIdxInterface, AccountUnlockOptions, IdxTransaction } from './types';
+export declare function unlockAccount(authClient: OktaAuthIdxInterface, options?: AccountUnlockOptions): Promise<IdxTransaction>;

package/types/lib/idx/util.d.ts

@@ -0,0 +1,14 @@
+import { RemediationValues, Remediator } from './remediators';
+import { OktaAuthIdxInterface, IdxFeature, NextStep, RemediateOptions, RemediationResponse, RunOptions } from './types';
+import { IdxMessage, IdxRemediation, IdxRemediationValue, IdxResponse } from './types/idx-js';
+export declare function isTerminalResponse(idxResponse: IdxResponse): boolean;
+export declare function canSkipFn(idxResponse: IdxResponse): boolean;
+export declare function canResendFn(idxResponse: IdxResponse): boolean;
+export declare function getMessagesFromIdxRemediationValue(value?: IdxRemediationValue[]): IdxMessage[] | undefined;
+export declare function getMessagesFromResponse(idxResponse: IdxResponse, options: RunOptions): IdxMessage[];
+export declare function getEnabledFeatures(idxResponse: IdxResponse): IdxFeature[];
+export declare function getAvailableSteps(authClient: OktaAuthIdxInterface, idxResponse: IdxResponse, useGenericRemediator?: boolean): NextStep[];
+export declare function filterValuesForRemediation(idxResponse: IdxResponse, remediationName: string, values: RemediationValues): RemediationValues;
+export declare function getRemediator(idxRemediations: IdxRemediation[], values: RemediationValues, options: RemediateOptions): Remediator | undefined;
+export declare function getNextStep(authClient: OktaAuthIdxInterface, remediator: Remediator, idxResponse: IdxResponse): NextStep;
+export declare function handleFailedResponse(authClient: OktaAuthIdxInterface, idxResponse: IdxResponse, options?: {}): RemediationResponse;

package/types/lib/idx/webauthn.d.ts

@@ -0,0 +1,31 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+import { ActivationData, ChallengeData, IdxAuthenticator, WebauthnEnrollValues, WebauthnVerificationValues } from './types';
+export interface WebauthnAPI {
+    getAssertion(credential: PublicKeyCredential): WebauthnVerificationValues;
+    getAttestation(credential: PublicKeyCredential): WebauthnEnrollValues;
+    buildCredentialRequestOptions(challengeData: ChallengeData, authenticatorEnrollments: IdxAuthenticator[]): CredentialRequestOptions;
+    buildCredentialCreationOptions(activationData: ActivationData, authenticatorEnrollments: IdxAuthenticator[]): CredentialCreationOptions;
+}
+export declare const buildCredentialCreationOptions: (activationData: ActivationData, authenticatorEnrollments: IdxAuthenticator[]) => CredentialCreationOptions;
+export declare const buildCredentialRequestOptions: (challengeData: ChallengeData, authenticatorEnrollments: IdxAuthenticator[]) => CredentialRequestOptions;
+export declare const getAttestation: (credential: PublicKeyCredential) => {
+    id: string;
+    clientData: any;
+    attestation: any;
+};
+export declare const getAssertion: (credential: PublicKeyCredential) => {
+    id: string;
+    clientData: any;
+    authenticatorData: any;
+    signatureData: any;
+};

package/types/lib/myaccount/factory.d.ts

@@ -0,0 +1,6 @@
+import { StorageManagerConstructor } from '../storage/types';
+import { OktaAuthConstructor, OktaAuthOptionsConstructor } from '../base/types';
+import { OAuthStorageManagerInterface, PKCETransactionMeta, TransactionManagerConstructor, TransactionManagerInterface } from '../oidc/types';
+import { OktaAuthCoreOptions } from '../core/types';
+import { OktaAuthMyAccountInterface } from './types';
+export declare function createOktaAuthMyAccount<M extends PKCETransactionMeta = PKCETransactionMeta, S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>, O extends OktaAuthCoreOptions = OktaAuthCoreOptions, TM extends TransactionManagerInterface = TransactionManagerInterface>(StorageManagerConstructor: StorageManagerConstructor<S>, OptionsConstructor: OktaAuthOptionsConstructor<O>, TransactionManager: TransactionManagerConstructor<TM>): OktaAuthConstructor<OktaAuthMyAccountInterface<M, S, O>>;

package/types/lib/myaccount/index.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ */
+export * from './api';
+export * from './factory';
+export * from './mixin';
+export * from './types';

package/types/lib/myaccount/mixin.d.ts

@@ -0,0 +1,4 @@
+import { OktaAuthConstructor } from '../base/types';
+import { OAuthStorageManagerInterface, OAuthTransactionMeta, OktaAuthOAuthInterface, OktaAuthOAuthOptions, PKCETransactionMeta } from '../oidc/types';
+import { OktaAuthMyAccountInterface } from './types';
+export declare function mixinMyAccount<M extends OAuthTransactionMeta = PKCETransactionMeta, S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>, O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions, TBase extends OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O>> = OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O>>>(Base: TBase): TBase & OktaAuthConstructor<OktaAuthMyAccountInterface<M, S, O>>;

package/types/lib/myaccount/request.d.ts

@@ -0,0 +1,29 @@
+import { BaseTransaction } from './transactions';
+import { MyAccountRequestOptions as RequestOptions } from './types';
+import { OktaAuthOAuthInterface } from '../oidc/types';
+export declare type TransactionLink = {
+    href: string;
+    hints?: {
+        allow?: string[];
+    };
+};
+declare type TransactionLinks = {
+    self: TransactionLink;
+    [property: string]: TransactionLink;
+};
+declare type SendRequestOptions = RequestOptions & {
+    url: string;
+    method: string;
+    transactionClassName?: string;
+};
+export declare function sendRequest<T extends BaseTransaction>(oktaAuth: OktaAuthOAuthInterface, options: SendRequestOptions): Promise<T | T[]>;
+export declare type GenerateRequestFnFromLinksOptions = {
+    oktaAuth: OktaAuthOAuthInterface;
+    accessToken: string;
+    methodName: string;
+    links: TransactionLinks;
+    transactionClassName?: string;
+};
+declare type IRequestFnFromLinks = <T extends BaseTransaction>(payload?: any) => Promise<T | T[]>;
+export declare function generateRequestFnFromLinks({ oktaAuth, accessToken, methodName, links, transactionClassName }: GenerateRequestFnFromLinksOptions): IRequestFnFromLinks;
+export {};

package/types/lib/myaccount/transactions/Base.d.ts

@@ -0,0 +1,15 @@
+import { OktaAuthHttpInterface } from '../../http/types';
+import { TransactionLink } from '../request';
+declare type TransactionOptions = {
+    res: {
+        headers: Record<string, string>;
+        _links?: Record<string, TransactionLink>;
+        [property: string]: unknown;
+    };
+    accessToken: string;
+};
+export default class BaseTransaction {
+    headers?: Record<string, string>;
+    constructor(oktaAuth: OktaAuthHttpInterface, options: TransactionOptions);
+}
+export {};