@okta/okta-auth-js 5.11.0 → 6.2.0

package/lib/idx/idx-js/index.d.ts

@@ -0,0 +1,51 @@
+/*!
+ * 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.
+ */
+declare const _default: {
+    start: ({ withCredentials, clientId, domain, issuer, stateHandle, interactionHandle, version, redirectUri, state, scopes, codeChallenge, codeChallengeMethod, activationToken, recoveryToken }: {
+        withCredentials: any;
+        clientId: any;
+        domain: any;
+        issuer: any;
+        stateHandle: any;
+        interactionHandle: any;
+        version: any;
+        redirectUri: any;
+        state: any;
+        scopes: any;
+        codeChallenge: any;
+        codeChallengeMethod: any;
+        activationToken: any;
+        recoveryToken: any;
+    }) => Promise<import("../types/idx-js").IdxResponse>;
+    introspect: ({ withCredentials, domain, interactionHandle, stateHandle, version, }: import("./introspect").IntrospectOptions) => Promise<any>;
+    interact: ({ withCredentials, clientId, baseUrl, scopes, redirectUri, codeChallenge, codeChallengeMethod, state, activationToken, recoveryToken, clientSecret, }: {
+        withCredentials: any;
+        clientId: any;
+        baseUrl: any;
+        scopes?: string[] | undefined;
+        redirectUri: any;
+        codeChallenge: any;
+        codeChallengeMethod: any;
+        state: any;
+        activationToken: any;
+        recoveryToken: any;
+        clientSecret: any;
+    }) => Promise<any>;
+    makeIdxState: typeof import("./v1/makeIdxState").makeIdxState;
+    client: {
+        interceptors: {
+            request: import("./client").Interceptor;
+        };
+    };
+    LATEST_SUPPORTED_IDX_API_VERSION: string;
+};
+export default _default;

package/lib/idx/idx-js/interact.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * 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.
+ */
+declare const interact: ({ withCredentials, clientId, baseUrl, scopes, redirectUri, codeChallenge, codeChallengeMethod, state, activationToken, recoveryToken, clientSecret, }: {
+    withCredentials: any;
+    clientId: any;
+    baseUrl: any;
+    scopes?: string[] | undefined;
+    redirectUri: any;
+    codeChallenge: any;
+    codeChallengeMethod: any;
+    state: any;
+    activationToken: any;
+    recoveryToken: any;
+    clientSecret: any;
+}) => Promise<any>;
+export default interact;

package/lib/idx/idx-js/introspect.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * 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.
+ */
+export interface IntrospectOptions {
+    domain: string;
+    withCredentials?: boolean;
+    interactionHandle?: string;
+    stateHandle?: string;
+    version?: string;
+}
+declare const introspect: ({ withCredentials, domain, interactionHandle, stateHandle, version, }: IntrospectOptions) => Promise<any>;
+export default introspect;

package/lib/idx/idx-js/parsers.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * 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.
+ */
+declare const parsersForVersion: (version: any) => {
+    makeIdxState: typeof import("./v1/makeIdxState").makeIdxState;
+};
+export default parsersForVersion;

package/lib/idx/idx-js/util.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * 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.
+ */
+export declare function validateVersionConfig(version: any): void;

package/lib/idx/idx-js/v1/actionParser.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * 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.
+ */
+export declare const divideActionParamsByMutability: (actionList: any) => {
+    defaultParams: {};
+    neededParams: never[];
+    immutableParams: {};
+};

package/lib/idx/idx-js/v1/generateIdxAction.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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.
+ */
+declare const generateIdxAction: (actionDefinition: any, toPersist: any) => (params: any) => Promise<import("../../types/idx-js").IdxResponse>;
+export default generateIdxAction;

package/lib/idx/idx-js/v1/idxResponseParser.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * 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.
+ */
+export declare const parseNonRemediations: (idxResponse: any, toPersist?: {}) => {
+    context: {};
+    actions: {};
+};
+export declare const parseIdxResponse: (idxResponse: any, toPersist?: {}) => {
+    remediations: IdxRemediation[];
+    context: any;
+    actions: any;
+};

package/lib/idx/idx-js/v1/makeIdxState.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { IdxResponse } from '../../types/idx-js';
+export declare function makeIdxState(idxResponse: any, toPersist: any): IdxResponse;

package/lib/idx/idx-js/v1/parsers.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * 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 { makeIdxState } from './makeIdxState';
+declare const _default: {
+    makeIdxState: typeof makeIdxState;
+};
+export default _default;

package/lib/idx/idx-js/v1/remediationParser.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * 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.
+ */
+export declare const generateRemediationFunctions: (remediationValue: any, toPersist?: {}) => any;

package/lib/idx/index.d.ts

@@ -9,14 +9,16 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-export * from './authenticate';
-export * from './cancel';
-export * from './interact';
-export * from './introspect';
-export * from './poll';
-export * from './proceed';
-export * from './register';
-export * from './recoverPassword';
-export * from './handleInteractionCodeRedirect';
-export * from './startTransaction';
+export { authenticate } from './authenticate';
+export { cancel } from './cancel';
+export { handleEmailVerifyCallback, isEmailVerifyCallback, parseEmailVerifyCallback, isEmailVerifyCallbackError, } from './emailVerify';
+export { interact } from './interact';
+export { introspect } from './introspect';
+export { poll } from './poll';
+export { proceed, canProceed } from './proceed';
+export { register } from './register';
+export { recoverPassword } from './recoverPassword';
+export { handleInteractionCodeRedirect } from './handleInteractionCodeRedirect';
+export { startTransaction } from './startTransaction';
+export { unlockAccount } from './unlockAccount';
 export * from './transactionMeta';

package/lib/idx/interact.d.ts

@@ -1,23 +1,17 @@
-/*!
- * 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 { OktaAuth, IdxTransactionMeta } from '../types';
+import { OktaAuthInterface, IdxTransactionMeta } from '../types';
 export interface InteractOptions {
+    withCredentials?: boolean;
     state?: string;
     scopes?: string[];
+    codeChallenge?: string;
+    codeChallengeMethod?: string;
     activationToken?: string;
+    recoveryToken?: string;
+    clientSecret?: string;
 }
 export interface InteractResponse {
     state?: string;
     interactionHandle: string;
     meta: IdxTransactionMeta;
 }
-export declare function interact(authClient: OktaAuth, options?: InteractOptions): Promise<InteractResponse>;
+export declare function interact(authClient: OktaAuthInterface, options?: InteractOptions): Promise<InteractResponse>;

package/lib/idx/introspect.d.ts

@@ -9,11 +9,12 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-import { OktaAuth } from '../types';
+import { OktaAuthInterface } from '../types';
 import { IdxResponse } from './types/idx-js';
 export interface IntrospectOptions {
+    withCredentials?: boolean;
     interactionHandle?: string;
     stateHandle?: string;
-    stateTokenExternalId?: string;
+    version?: string;
 }
-export declare function introspect(authClient: OktaAuth, options: IntrospectOptions): Promise<IdxResponse>;
+export declare function introspect(authClient: OktaAuthInterface, options?: IntrospectOptions): Promise<IdxResponse>;

package/lib/idx/poll.d.ts

@@ -9,5 +9,5 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-import { IdxPollOptions, IdxTransaction, OktaAuth } from '../types';
-export declare function poll(authClient: OktaAuth, options?: IdxPollOptions): Promise<IdxTransaction>;
+import { IdxPollOptions, IdxTransaction, OktaAuthInterface } from '../types';
+export declare function poll(authClient: OktaAuthInterface, options?: IdxPollOptions): Promise<IdxTransaction>;

package/lib/idx/proceed.d.ts

@@ -9,13 +9,16 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-import { OktaAuth, IdxTransaction } from '../types';
+import { OktaAuthInterface, IdxTransaction } from '../types';
 import { AuthenticationOptions } from './authenticate';
-import { EnrollPollValues as EnrollPollOptions } from './remediators';
+import { EnrollPollValues as EnrollPollOptions, SelectEnrollmentChannelValues as SelectEnrollmentChannelOptions } from './remediators';
 import { RegistrationOptions } from './register';
 import { PasswordRecoveryOptions } from './recoverPassword';
-export declare type ProceedOptions = AuthenticationOptions & RegistrationOptions & PasswordRecoveryOptions & EnrollPollOptions;
-export declare function canProceed(authClient: OktaAuth, options?: {
+import { AccountUnlockOptions } from './unlockAccount';
+export declare type ProceedOptions = AuthenticationOptions & RegistrationOptions & PasswordRecoveryOptions & AccountUnlockOptions & EnrollPollOptions & SelectEnrollmentChannelOptions & {
+    step?: string;
+};
+export declare function canProceed(authClient: OktaAuthInterface, options?: {
     state?: string;
 }): boolean;
-export declare function proceed(authClient: OktaAuth, options?: ProceedOptions): Promise<IdxTransaction>;
+export declare function proceed(authClient: OktaAuthInterface, options?: ProceedOptions): Promise<IdxTransaction>;

package/lib/idx/recoverPassword.d.ts

@@ -10,6 +10,6 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { IdentifyValues, SelectAuthenticatorAuthenticateValues, ChallengeAuthenticatorValues, AuthenticatorVerificationDataValues, ResetAuthenticatorValues, ReEnrollAuthenticatorValues } from './remediators';
-import { OktaAuth, IdxOptions, IdxTransaction } from '../types';
+import { OktaAuthInterface, IdxOptions, IdxTransaction } from '../types';
 export declare type PasswordRecoveryOptions = IdxOptions & IdentifyValues & SelectAuthenticatorAuthenticateValues & ChallengeAuthenticatorValues & ResetAuthenticatorValues & AuthenticatorVerificationDataValues & ReEnrollAuthenticatorValues;
-export declare function recoverPassword(authClient: OktaAuth, options: PasswordRecoveryOptions): Promise<IdxTransaction>;
+export declare function recoverPassword(authClient: OktaAuthInterface, options?: PasswordRecoveryOptions): Promise<IdxTransaction>;

package/lib/idx/register.d.ts

@@ -10,6 +10,6 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { EnrollProfileValues, SelectAuthenticatorEnrollValues, EnrollAuthenticatorValues, AuthenticatorEnrollmentDataValues, SkipValues } from './remediators';
-import { IdxOptions, IdxTransaction, OktaAuth } from '../types';
+import { IdxOptions, IdxTransaction, OktaAuthInterface } from '../types';
 export declare type RegistrationOptions = IdxOptions & EnrollProfileValues & SelectAuthenticatorEnrollValues & EnrollAuthenticatorValues & AuthenticatorEnrollmentDataValues & SkipValues;
-export declare function register(authClient: OktaAuth, options?: RegistrationOptions): Promise<IdxTransaction>;
+export declare function register(authClient: OktaAuthInterface, options?: RegistrationOptions): Promise<IdxTransaction>;

package/lib/idx/remediate.d.ts

@@ -10,8 +10,8 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { Remediator, RemediationValues } from './remediators';
-import { RunOptions } from './run';
-import { NextStep, IdxMessage } from './types';
+import { NextStep, IdxMessage, FlowIdentifier } from './types';
+import { RemediationFlow } from './flow';
 import { IdxResponse, IdxRemediation } from './types/idx-js';
 interface RemediationResponse {
     idxResponse?: IdxResponse;
@@ -20,6 +20,12 @@ interface RemediationResponse {
     terminal?: boolean;
     canceled?: boolean;
 }
-export declare function getRemediator(idxRemediations: IdxRemediation[], values: RemediationValues, options: RunOptions): Remediator;
-export declare function remediate(idxResponse: IdxResponse, values: RemediationValues, options: RunOptions): Promise<RemediationResponse>;
+export interface RemediateOptions {
+    remediators?: RemediationFlow;
+    actions?: string[];
+    flow?: FlowIdentifier;
+    step?: string;
+}
+export declare function getRemediator(idxRemediations: IdxRemediation[], values: RemediationValues, options: RemediateOptions): Remediator;
+export declare function remediate(idxResponse: IdxResponse, values: RemediationValues, options: RemediateOptions): Promise<RemediationResponse>;
 export {};

package/lib/idx/remediators/AuthenticatorEnrollmentData.d.ts

@@ -18,9 +18,9 @@ export declare class AuthenticatorEnrollmentData extends AuthenticatorData {
     static remediationName: string;
     values: AuthenticatorEnrollmentDataValues;
     mapAuthenticator(): {
-        id: string;
-        methodType: string;
-        phoneNumber: string;
+        id: string | import("../types/idx-js").IdxRemediationValueForm | undefined;
+        methodType: string | undefined;
+        phoneNumber: string | undefined;
     };
     getInputAuthenticator(): ({
         name: string;

package/lib/idx/remediators/AuthenticatorVerificationData.d.ts

@@ -10,15 +10,15 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { AuthenticatorData, AuthenticatorDataValues } from './Base/AuthenticatorData';
+import { IdxRemediation } from '../types/idx-js';
 export declare type AuthenticatorVerificationDataValues = AuthenticatorDataValues;
 export declare class AuthenticatorVerificationData extends AuthenticatorData {
     static remediationName: string;
     values: AuthenticatorVerificationDataValues;
-    mapAuthenticator(): {
-        id: string;
-        enrollmentId: string;
-        methodType: string;
-    };
+    shouldProceedWithEmailAuthenticator: boolean;
+    constructor(remediation: IdxRemediation, values?: AuthenticatorDataValues);
+    canRemediate(): boolean;
+    mapAuthenticator(): {} | undefined;
     getInputAuthenticator(): import("../types/idx-js").IdxRemediationValue[] | {
         name: string;
         type: string;

package/lib/idx/remediators/Base/AuthenticatorData.d.ts

@@ -10,29 +10,29 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { Remediator, RemediationValues } from './Remediator';
-import { IdxRemediationValue, IdxOption, IdxRemediation } from '../../types/idx-js';
-import { Authenticator } from '../../types';
+import { IdxRemediationValue, IdxOption, IdxRemediation, IdxAuthenticator } from '../../types/idx-js';
 export declare type AuthenticatorDataValues = RemediationValues & {
     methodType?: string;
 };
 export declare class AuthenticatorData extends Remediator {
     map: {
-        authenticator: any[];
+        authenticator: never[];
     };
     values: AuthenticatorDataValues;
-    authenticator: Authenticator;
+    authenticator: IdxAuthenticator;
     constructor(remediation: IdxRemediation, values?: AuthenticatorDataValues);
     protected formatAuthenticatorData(): void;
-    protected getAuthenticatorData(): Authenticator;
+    protected getAuthenticatorData(): import("../../types").Authenticator | undefined;
     canRemediate(): boolean;
     getNextStep(): {
         options: IdxOption[];
         name: string;
-        authenticator?: import("../../types/idx-js").IdxAuthenticator;
-        canSkip?: boolean;
-        canResend?: boolean;
-        inputs?: import("../../types").Input[];
-        poll?: import("../../types").IdxPollOptions;
+        authenticator?: IdxAuthenticator | undefined;
+        canSkip?: boolean | undefined;
+        canResend?: boolean | undefined;
+        inputs?: import("../../types").Input[] | undefined;
+        poll?: import("../../types").IdxPollOptions | undefined;
+        authenticatorEnrollments?: IdxAuthenticator[] | undefined;
     };
     protected mapAuthenticatorDataFromValues(authenticatorData?: any): any;
     protected getAuthenticatorFromRemediation(): IdxRemediationValue;

package/lib/idx/remediators/Base/SelectAuthenticator.d.ts

@@ -16,10 +16,12 @@ export declare type SelectAuthenticatorValues = RemediationValues & {
 };
 export declare class SelectAuthenticator extends Remediator {
     values: SelectAuthenticatorValues;
-    selectedAuthenticator: IdxAuthenticator;
+    selectedAuthenticator?: IdxAuthenticator;
+    selectedOption?: any;
     map: {
-        authenticator: any[];
+        authenticator: never[];
     };
+    findMatchedOption(authenticators: any, options: any): any;
     canRemediate(): boolean;
     getNextStep(): {
         options: {
@@ -27,11 +29,12 @@ export declare class SelectAuthenticator extends Remediator {
             value: string;
         }[];
         name: string;
-        authenticator?: IdxAuthenticator;
-        canSkip?: boolean;
-        canResend?: boolean;
-        inputs?: import("../../types").Input[];
-        poll?: import("../../types").IdxPollOptions;
+        authenticator?: IdxAuthenticator | undefined;
+        canSkip?: boolean | undefined;
+        canResend?: boolean | undefined;
+        inputs?: import("../../types").Input[] | undefined;
+        poll?: import("../../types").IdxPollOptions | undefined;
+        authenticatorEnrollments?: IdxAuthenticator[] | undefined;
     };
     mapAuthenticator(remediationValue: IdxRemediationValue): {
         id: any;

package/lib/idx/remediators/Base/VerifyAuthenticator.d.ts

@@ -10,22 +10,18 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { Remediator, RemediationValues } from './Remediator';
-import { Authenticator } from '../../authenticator';
-import { IdxRemediation } from '../../types/idx-js';
-export interface VerifyAuthenticatorValues extends RemediationValues {
-    verificationCode?: string;
-    password?: string;
-    questionKey?: string;
-    question?: string;
-    answer?: string;
-}
+import { Authenticator, AuthenticatorValues } from '../../authenticator';
+import { IdxRemediation, IdxContext } from '../../types/idx-js';
+import { NextStep } from '../../types';
+export declare type VerifyAuthenticatorValues = AuthenticatorValues & RemediationValues;
 export declare class VerifyAuthenticator extends Remediator {
-    authenticator: Authenticator;
+    authenticator: Authenticator<VerifyAuthenticatorValues>;
     values: VerifyAuthenticatorValues;
     map: {
-        credentials: any[];
+        credentials: never[];
     };
-    constructor(remediation: IdxRemediation, values?: RemediationValues);
+    constructor(remediation: IdxRemediation, values?: VerifyAuthenticatorValues);
+    getNextStep(context?: IdxContext): NextStep;
     canRemediate(): boolean;
     mapCredentials(): import("../../authenticator").Credentials;
     getInputCredentials(input: any): any;

package/lib/idx/remediators/EnrollProfile.d.ts

@@ -19,7 +19,7 @@ export declare class EnrollProfile extends Remediator {
     static remediationName: string;
     values: EnrollProfileValues;
     map: {
-        userProfile: any[];
+        userProfile: never[];
     };
     canRemediate(): boolean;
     mapUserProfile({ form: { value: profileAttributes } }: {

package/lib/idx/remediators/EnrollmentChannelData.d.ts

@@ -0,0 +1,54 @@
+/*!
+ * 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 { IdxContext } from '../types/idx-js';
+export declare type EnrollmentChannelDataValues = RemediationValues & {
+    email?: string;
+    phoneNumber?: string;
+};
+export declare class EnrollmentChannelData extends Remediator {
+    static remediationName: string;
+    values: EnrollmentChannelDataValues;
+    map: {
+        email: never[];
+        phoneNumber: never[];
+    };
+    getInputEmail(): {
+        name: string;
+        type: string;
+        required: boolean;
+        label: string;
+    }[];
+    getInputPhoneNumber(): {
+        name: string;
+        type: string;
+        required: boolean;
+        label: string;
+    }[];
+    canRemediate(): boolean;
+    getNextStep(context: IdxContext): {
+        authenticator: import("../types/idx-js").IdxAuthenticator;
+        name: string;
+        canSkip?: boolean | undefined;
+        canResend?: boolean | undefined;
+        inputs?: import("../types").Input[] | undefined;
+        options?: import("../types/idx-js").IdxOption[] | undefined;
+        poll?: import("../types").IdxPollOptions | undefined;
+        authenticatorEnrollments?: import("../types/idx-js").IdxAuthenticator[] | undefined;
+    };
+    getData(): {
+        stateHandle: string | undefined;
+        email: string | undefined;
+        phoneNumber: string | undefined;
+    };
+    getValuesAfterProceed(): {};
+}

package/lib/idx/remediators/Identify.d.ts

@@ -19,12 +19,12 @@ export declare class Identify extends Remediator {
     values: IdentifyValues;
     map: {
         identifier: string[];
-        credentials: any[];
+        credentials: never[];
         rememberMe: string[];
     };
     canRemediate(): boolean;
     mapCredentials(): {
-        passcode: string;
+        passcode: string | undefined;
     };
     getInputCredentials(input: any): any;
 }

package/lib/idx/remediators/ReEnrollAuthenticator.d.ts

@@ -17,10 +17,10 @@ export declare class ReEnrollAuthenticator extends Remediator {
     static remediationName: string;
     values: ReEnrollAuthenticatorValues;
     map: {
-        credentials: any[];
+        credentials: never[];
     };
     mapCredentials(): {
-        passcode: string;
+        passcode: string | undefined;
     };
     getInputCredentials(input: any): any;
 }

package/lib/idx/remediators/RedirectIdp.d.ts

@@ -15,8 +15,8 @@ export declare class RedirectIdp extends Remediator {
     canRemediate(): boolean;
     getNextStep(): {
         name: string;
-        type: string;
-        idp: import("../types/idx-js").IdpConfig;
-        href: string;
+        type: string | undefined;
+        idp: import("../types/idx-js").IdpConfig | undefined;
+        href: string | undefined;
     };
 }