@okta/okta-auth-js 5.5.0 → 5.9.0

package/lib/AuthStateManager.d.ts

@@ -19,12 +19,14 @@ export declare class AuthStateManager {
         updateAuthStatePromise: typeof PCancelable;
         canceledTimes: number;
     };
-    _authState: AuthState;
+    _authState: AuthState | null;
+    _prevAuthState: AuthState | null;
     _logOptions: AuthStateLogOptions;
     _lastEventTimestamp: number;
     constructor(sdk: OktaAuth);
     _setLogOptions(options: any): void;
-    getAuthState(): AuthState;
+    getAuthState(): AuthState | null;
+    getPreviousAuthState(): AuthState | null;
     updateAuthState(): Promise<AuthState>;
     subscribe(handler: any): void;
     unsubscribe(handler?: any): void;

package/lib/OktaAuth.d.ts

@@ -11,6 +11,7 @@
  */
 import { OktaAuth as SDKInterface, OktaAuthOptions, AccessToken, RefreshToken, TokenAPI, FeaturesAPI, SignoutAPI, FingerprintAPI, UserClaims, SigninWithRedirectOptions, SigninWithCredentialsOptions, SignoutOptions, Tokens, ForgotPasswordOptions, VerifyRecoveryTokenOptions, TransactionAPI, SessionAPI, SigninAPI, PkceAPI, SigninOptions, IdxAPI, SignoutRedirectUrlOptions, HttpAPI } from './types';
 import { AuthTransaction } from './tx';
+import { EmailVerifyCallbackResponse } from './util';
 import { TokenManager } from './TokenManager';
 import PromiseQueue from './PromiseQueue';
 import { AuthStateManager } from './AuthStateManager';
@@ -43,8 +44,11 @@ declare class OktaAuth implements SDKInterface, SigninAPI, SignoutAPI {
     constructor(args: OktaAuthOptions);
     start(): void;
     stop(): void;
-    isInteractionRequired(): boolean;
+    setHeaders(headers: any): void;
+    isInteractionRequired(hashOrSearch?: string): boolean;
     isInteractionRequiredError(error: Error): boolean;
+    isEmailVerifyCallback(urlPath: string): boolean;
+    parseEmailVerifyCallback(urlPath: string): EmailVerifyCallbackResponse;
     signIn(opts: SigninOptions): Promise<AuthTransaction>;
     signInWithCredentials(opts: SigninWithCredentialsOptions): Promise<AuthTransaction>;
     signInWithRedirect(opts?: SigninWithRedirectOptions): Promise<void>;
@@ -63,11 +67,11 @@ declare class OktaAuth implements SDKInterface, SigninAPI, SignoutAPI {
      * Store parsed tokens from redirect url
      */
     storeTokensFromRedirect(): Promise<void>;
-    setOriginalUri(originalUri: string): void;
-    getOriginalUri(): string;
-    removeOriginalUri(): void;
+    setOriginalUri(originalUri: string, state?: string): void;
+    getOriginalUri(state?: string): string;
+    removeOriginalUri(state?: string): void;
     isLoginRedirect(): boolean;
-    handleLoginRedirect(tokens?: Tokens): Promise<void>;
+    handleLoginRedirect(tokens?: Tokens, originalUri?: string): Promise<void>;
     isPKCE(): boolean;
     hasResponseType(responseType: string): boolean;
     isAuthorizationCodeFlow(): boolean;

package/lib/StorageManager.d.ts

@@ -18,6 +18,8 @@ export default class StorageManager {
     getOptionsForSection(sectionName: string, overrideOptions?: StorageOptions): StorageOptions;
     getStorage(options: StorageOptions): SimpleStorage;
     getTransactionStorage(options?: StorageOptions): TransactionStorage;
+    getSharedTansactionStorage(options?: StorageOptions): TransactionStorage;
+    getOriginalUriStorage(options?: StorageOptions): TransactionStorage;
     getIdxResponseStorage(options?: StorageOptions): IdxResponseStorage;
     getTokenStorage(options?: StorageOptions): StorageProvider;
     getHttpCache(options?: StorageOptions): StorageProvider;

package/lib/TransactionManager.d.ts

@@ -12,6 +12,9 @@
 import StorageManager from './StorageManager';
 import { TransactionMeta, PKCETransactionMeta, OAuthTransactionMeta, TransactionMetaOptions, TransactionManagerOptions } from './types';
 import { RawIdxResponse } from './idx/types/idx-js';
+export interface ClearTransactionMetaOptions extends TransactionMetaOptions {
+    clearSharedStorage?: boolean;
+}
 export default class TransactionManager {
     options: TransactionManagerOptions;
     storageManager: StorageManager;
@@ -19,8 +22,9 @@ export default class TransactionManager {
     saveNonceCookie: boolean;
     saveStateCookie: boolean;
     saveParamsCookie: boolean;
+    enableSharedStorage: boolean;
     constructor(options: TransactionManagerOptions);
-    clear(options?: TransactionMetaOptions): void;
+    clear(options?: ClearTransactionMetaOptions): void;
     save(meta: TransactionMeta, options?: TransactionMetaOptions): void;
     exists(options?: TransactionMetaOptions): boolean;
     load(options?: TransactionMetaOptions): TransactionMeta;
@@ -30,4 +34,5 @@ export default class TransactionManager {
     loadLegacyOAuthParams(): OAuthTransactionMeta;
     saveIdxResponse(idxResponse: RawIdxResponse): void;
     loadIdxResponse(): RawIdxResponse;
+    clearIdxResponse(): void;
 }

package/lib/constants.d.ts

@@ -20,6 +20,8 @@ export declare const TOKEN_STORAGE_NAME = "okta-token-storage";
 export declare const CACHE_STORAGE_NAME = "okta-cache-storage";
 export declare const PKCE_STORAGE_NAME = "okta-pkce-storage";
 export declare const TRANSACTION_STORAGE_NAME = "okta-transaction-storage";
+export declare const SHARED_TRANSACTION_STORAGE_NAME = "okta-shared-transaction-storage";
+export declare const ORIGINAL_URI_STORAGE_NAME = "okta-original-uri-storage";
 export declare const IDX_RESPONSE_STORAGE_NAME = "okta-idx-response-storage";
 export declare const ACCESS_TOKEN_STORAGE_KEY = "accessToken";
 export declare const ID_TOKEN_STORAGE_KEY = "idToken";

package/lib/crypto/base64.d.ts

@@ -12,6 +12,6 @@
 export declare function stringToBase64Url(str: any): any;
 export declare function base64ToBase64Url(b64: any): any;
 export declare function base64UrlToBase64(b64u: any): any;
-export declare function base64UrlToString(b64u: any): string;
+export declare function base64UrlToString(b64u: any): any;
 export declare function stringToBuffer(str: any): Uint8Array;
-export declare function base64UrlDecode(str: any): string;
+export declare function base64UrlDecode(str: any): any;

package/lib/crypto/oidcHash.d.ts

@@ -9,4 +9,4 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-export declare function getOidcHash(str: any): Promise<any>;
+export declare function getOidcHash(str: any): any;

package/lib/crypto/verifyToken.d.ts

@@ -9,4 +9,4 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-export declare function verifyToken(idToken: any, key: any): Promise<boolean>;
+export declare function verifyToken(idToken: any, key: any): any;

package/{esm/oidc/endpoints/index.js → lib/idx/flow/AuthenticationFlow.d.ts}

@@ -6,10 +6,8 @@
  * 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 './authorize';
-export * from './token';
-export * from './well-known';
-//# sourceMappingURL=index.js.map
+import { RemediationFlow } from './RemediationFlow';
+export declare const AuthenticationFlow: RemediationFlow;

package/lib/idx/flow/FlowSpecification.d.ts

@@ -0,0 +1,10 @@
+import { OktaAuth, FlowIdentifier } from '../../types';
+import { FlowMonitor } from './FlowMonitor';
+import { RemediationFlow } from './RemediationFlow';
+export interface FlowSpecification {
+    flow: FlowIdentifier;
+    remediators: RemediationFlow;
+    flowMonitor: FlowMonitor;
+    actions?: string[];
+}
+export declare function getFlowSpecification(oktaAuth: OktaAuth, flow?: FlowIdentifier): FlowSpecification;

package/{esm/crypto/index.js → lib/idx/flow/PasswordRecoveryFlow.d.ts}

@@ -6,11 +6,8 @@
  * 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 './base64';
-export * from './oidcHash';
-export * from './verifyToken';
-export * from './webcrypto';
-//# sourceMappingURL=index.js.map
+import { RemediationFlow } from './RemediationFlow';
+export declare const PasswordRecoveryFlow: RemediationFlow;

package/{esm/tx/TransactionState.js → lib/idx/flow/RegistrationFlow.d.ts}

@@ -6,8 +6,8 @@
  * 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 class TransactionState {}
-//# sourceMappingURL=TransactionState.js.map
+import { RemediationFlow } from './RemediationFlow';
+export declare const RegistrationFlow: RemediationFlow;

package/lib/idx/flow/RemediationFlow.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 * as remediators from '../remediators';
+export declare type RemediationFlow = Record<string, typeof remediators.Remediator>;

package/lib/idx/{flowMonitors → flow}/index.d.ts

@@ -9,7 +9,12 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-export * from './FlowMonitor';
-export * from './RegistrationFlowMonitor';
+export * from './AuthenticationFlow';
 export * from './AuthenticationFlowMonitor';
+export * from './FlowMonitor';
+export * from './FlowSpecification';
+export * from './PasswordRecoveryFlow';
 export * from './PasswordRecoveryFlowMonitor';
+export * from './RegistrationFlow';
+export * from './RegistrationFlowMonitor';
+export * from './RemediationFlow';

package/lib/idx/index.d.ts

@@ -13,7 +13,9 @@ export * from './authenticate';
 export * from './cancel';
 export * from './interact';
 export * from './introspect';
+export * from './proceed';
 export * from './register';
 export * from './recoverPassword';
 export * from './handleInteractionCodeRedirect';
 export * from './startTransaction';
+export * from './transactionMeta';

package/lib/idx/introspect.d.ts

@@ -12,7 +12,8 @@
 import { OktaAuth } from '../types';
 import { IdxResponse } from './types/idx-js';
 export interface IntrospectOptions {
-    interactionHandle: string;
+    interactionHandle?: string;
     stateHandle?: string;
+    stateTokenExternalId?: string;
 }
 export declare function introspect(authClient: OktaAuth, options: IntrospectOptions): Promise<IdxResponse>;

package/{esm/errors/AuthApiError.js → lib/idx/proceed.d.ts}

@@ -9,22 +9,12 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-import CustomError from './CustomError';
-export default class AuthApiError extends CustomError {
-  constructor(err, xhr) {
-    var message = err.errorSummary;
-    super(message);
-    this.name = 'AuthApiError';
-    this.errorSummary = err.errorSummary;
-    this.errorCode = err.errorCode;
-    this.errorLink = err.errorLink;
-    this.errorId = err.errorId;
-    this.errorCauses = err.errorCauses;
-
-    if (xhr) {
-      this.xhr = xhr;
-    }
-  }
-
-}
-//# sourceMappingURL=AuthApiError.js.map
+import { OktaAuth, IdxTransaction } from '../types';
+import { AuthenticationOptions } from './authenticate';
+import { RegistrationOptions } from './register';
+import { PasswordRecoveryOptions } from './recoverPassword';
+export declare type ProceedOptions = AuthenticationOptions & RegistrationOptions & PasswordRecoveryOptions;
+export declare function canProceed(authClient: OktaAuth, options?: {
+    state?: string;
+}): boolean;
+export declare function proceed(authClient: OktaAuth, options?: ProceedOptions): Promise<IdxTransaction>;

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

@@ -24,13 +24,10 @@ export declare class AuthenticatorData extends Remediator {
     getNextStep(): {
         options: IdxOption[];
         name: string;
-        type?: string;
+        authenticator?: import("../../types/idx-js").IdxAuthenticator;
         canSkip?: boolean;
         canResend?: boolean;
-        inputs?: {
-            name: string;
-            required?: boolean;
-        }[];
+        inputs?: import("../../types").Input[];
     };
     protected getAuthenticatorFromValues(): Authenticator;
     protected mapAuthenticatorFromValues(authenticator?: Authenticator): Authenticator;

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

@@ -10,7 +10,7 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { NextStep, IdxMessage, Authenticator } from '../../types';
-import { IdxRemediation } from '../../types/idx-js';
+import { IdxAuthenticator, IdxRemediation } from '../../types/idx-js';
 export declare type IdxToRemediationValueMap = Record<string, string[]>;
 export interface RemediationValues {
     stateHandle?: string;
@@ -29,9 +29,6 @@ export declare class Remediator {
     getNextStep(): NextStep;
     private getInputs;
     getMessages(): IdxMessage[] | undefined;
-    getValuesAfterProceed(): {
-        authenticators: Authenticator[];
-        stateHandle?: string;
-    };
-    protected getRelatesToType(): string;
+    getValuesAfterProceed(): unknown;
+    protected getAuthenticator(): IdxAuthenticator | undefined;
 }

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

@@ -28,19 +28,16 @@ export declare class SelectAuthenticator extends Remediator {
             value: string;
         }[];
         name: string;
-        type?: string;
+        authenticator?: import("../../types/idx-js").IdxAuthenticator;
         canSkip?: boolean;
         canResend?: boolean;
-        inputs?: {
-            name: string;
-            required?: boolean;
-        }[];
+        inputs?: import("../../types").Input[];
     };
     mapAuthenticator(remediationValue: IdxRemediationValue): {
         id: any;
     };
     getInputAuthenticator(): {
         name: string;
-        type: string;
+        key: string;
     };
 }

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

@@ -15,7 +15,6 @@ export interface VerifyAuthenticatorValues extends RemediationValues {
     password?: string;
 }
 export declare class VerifyAuthenticator extends Remediator {
-    static remediationName: string;
     values: VerifyAuthenticatorValues;
     map: {
         credentials: any[];
@@ -25,4 +24,5 @@ export declare class VerifyAuthenticator extends Remediator {
         passcode: string;
     };
     getInputCredentials(input: any): any;
+    getValuesAfterProceed(): VerifyAuthenticatorValues;
 }

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

@@ -21,6 +21,7 @@ export declare class EnrollProfile extends Remediator {
     map: {
         userProfile: any[];
     };
+    canRemediate(): boolean;
     mapUserProfile({ form: { value: profileAttributes } }: {
         form: {
             value: any;

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

@@ -10,7 +10,6 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { Remediator, RemediationValues } from './Base/Remediator';
-import { Authenticator } from '../types';
 import { IdxRemediation } from '../types/idx-js';
 export interface IdentifyValues extends RemediationValues {
     username?: string;
@@ -22,6 +21,7 @@ export declare class Identify extends Remediator {
     map: {
         identifier: string[];
         credentials: any[];
+        rememberMe: string[];
     };
     constructor(remediation: IdxRemediation, values?: IdentifyValues);
     canRemediate(): boolean;
@@ -29,8 +29,5 @@ export declare class Identify extends Remediator {
         passcode: string;
     };
     getInputCredentials(input: any): any;
-    getValuesAfterProceed(): {
-        authenticators: Authenticator[];
-        stateHandle?: string;
-    };
+    getValuesAfterProceed(): unknown;
 }

package/lib/idx/run.d.ts

@@ -9,13 +9,13 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-import { FlowMonitor } from './flowMonitors';
-import * as remediators from './remediators';
-import { OktaAuth, IdxOptions, IdxTransaction } from '../types';
-export declare type RemediationFlow = Record<string, typeof remediators.Remediator>;
-export interface RunOptions {
-    flow?: RemediationFlow;
-    actions?: string[];
+import { FlowMonitor, RemediationFlow } from './flow';
+import { OktaAuth, IdxTransaction, FlowIdentifier } from '../types';
+import { ProceedOptions } from './proceed';
+export declare type RunOptions = ProceedOptions & {
+    flow?: FlowIdentifier;
+    remediators?: RemediationFlow;
     flowMonitor?: FlowMonitor;
-}
-export declare function run(authClient: OktaAuth, options: RunOptions & IdxOptions): Promise<IdxTransaction>;
+    actions?: string[];
+};
+export declare function run(authClient: OktaAuth, options?: RunOptions): Promise<IdxTransaction>;

package/lib/idx/transactionMeta.d.ts

@@ -9,10 +9,34 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-import { OktaAuth, IdxTransactionMeta } from '../types';
-export declare function createTransactionMeta(authClient: OktaAuth): Promise<import("../types").TokenParams>;
-export declare function transactionMetaExist(authClient: OktaAuth): boolean;
-export declare function getTransactionMeta(authClient: OktaAuth): Promise<IdxTransactionMeta>;
+import { OktaAuth, IdxTransactionMeta, TransactionMetaOptions } from '../types';
+export declare function createTransactionMeta(authClient: OktaAuth, options?: TransactionMetaOptions): Promise<{
+    flow: import("./types/FlowIdentifier").FlowIdentifier;
+    issuer: string;
+    pkce: boolean;
+    clientId: string;
+    redirectUri: string;
+    responseType: string | string[];
+    responseMode: string;
+    scopes: string[];
+    state: string;
+    nonce: string;
+    urls: {
+        issuer: any;
+        authorizeUrl: any;
+        userinfoUrl: any;
+        tokenUrl: any;
+        revokeUrl: any;
+        logoutUrl: any;
+    };
+    ignoreSignature: boolean;
+    codeVerifier: string;
+    codeChallengeMethod: string;
+    codeChallenge: string;
+}>;
+export declare function transactionMetaExist(authClient: OktaAuth, options?: TransactionMetaOptions): boolean;
+export declare function getSavedTransactionMeta(authClient: OktaAuth, options?: TransactionMetaOptions): IdxTransactionMeta;
+export declare function getTransactionMeta(authClient: OktaAuth, options?: TransactionMetaOptions): Promise<IdxTransactionMeta>;
 export declare function saveTransactionMeta(authClient: OktaAuth, meta: any): void;
 export declare function clearTransactionMeta(authClient: OktaAuth): void;
 export declare function isTransactionMetaValid(authClient: OktaAuth, meta: any): boolean;

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

@@ -0,0 +1 @@
+export declare type FlowIdentifier = 'default' | 'proceed' | 'authenticate' | 'login' | 'signin' | 'register' | 'signup' | 'enrollProfile' | 'recoverPassword' | 'resetPassword';

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

@@ -22,6 +22,7 @@ export interface IdxAuthenticator {
         complexity?: unknown;
         age?: unknown;
     };
+    contextualData?: unknown;
 }
 export interface IdxForm {
     value: IdxRemediationValue[];
@@ -42,6 +43,8 @@ export interface IdxRemediationValue {
     type?: string;
     required?: boolean;
     secret?: boolean;
+    visible?: boolean;
+    mutable?: boolean;
     value?: string;
     label?: string;
     form?: IdxForm;
@@ -62,6 +65,7 @@ export interface IdxRemediation {
     href?: string;
     method?: string;
     type?: string;
+    accepts?: string;
 }
 export interface IdxMessage {
     message: string;
@@ -100,3 +104,4 @@ export interface IdxResponse {
         interactionHandle?: string;
     };
 }
+export declare function isIdxResponse(obj: any): obj is IdxResponse;

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

@@ -10,28 +10,43 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { InteractOptions } from '../interact';
+import { IntrospectOptions } from '../introspect';
 import { APIError, Tokens } from '../../types';
 import { IdxTransactionMeta } from '../../types/Transaction';
-import { IdxMessage, IdxOption } from './idx-js';
+import { IdxAuthenticator, IdxMessage, IdxOption, IdxResponse } from './idx-js';
+import { FlowIdentifier } from './FlowIdentifier';
 export { IdxMessage } from './idx-js';
 export { AuthenticationOptions } from '../authenticate';
 export { RegistrationOptions } from '../register';
 export { PasswordRecoveryOptions } from '../recoverPassword';
+export { ProceedOptions } from '../proceed';
 export { CancelOptions } from '../cancel';
+export { FlowIdentifier };
 export declare enum IdxStatus {
-    SUCCESS = 0,
-    PENDING = 1,
-    FAILURE = 2,
-    TERMINAL = 3,
-    CANCELED = 4
+    SUCCESS = "SUCCESS",
+    PENDING = "PENDING",
+    FAILURE = "FAILURE",
+    TERMINAL = "TERMINAL",
+    CANCELED = "CANCELED"
 }
-declare type Input = {
+export declare enum AuthenticatorKey {
+    OKTA_PASSWORD = "okta_password",
+    OKTA_EMAIL = "okta_email",
+    OKTA_VERIFIER = "okta_verifier",
+    PHONE_NUMBER = "phone_number",
+    GOOGLE_AUTHENTICATOR = "google_otp"
+}
+export declare type Input = {
     name: string;
+    type?: string;
+    label?: string;
+    value?: string;
+    secret?: boolean;
     required?: boolean;
 };
 export declare type NextStep = {
     name: string;
-    type?: string;
+    authenticator?: IdxAuthenticator;
     canSkip?: boolean;
     canResend?: boolean;
     inputs?: Input[];
@@ -51,10 +66,13 @@ export interface IdxTransaction {
     meta?: IdxTransactionMeta;
     enabledFeatures?: IdxFeature[];
     availableSteps?: NextStep[];
+    _idxResponse?: IdxResponse;
 }
-export declare type IdxOptions = InteractOptions;
+export declare type IdxOptions = InteractOptions & IntrospectOptions & {
+    flow?: FlowIdentifier;
+};
 export declare type Authenticator = {
-    type: string;
+    key: string;
     methodType?: string;
     phoneNumber?: string;
 };

package/lib/oidc/getToken.d.ts

@@ -1,2 +1,2 @@
-import { OktaAuth, TokenParams } from '../types';
-export declare function getToken(sdk: OktaAuth, options: TokenParams): Promise<import("../types").TokenResponse>;
+import { OktaAuth, TokenParams, PopupParams } from '../types';
+export declare function getToken(sdk: OktaAuth, options: TokenParams & PopupParams): Promise<import("../types").TokenResponse>;

package/lib/oidc/parseFromUrl.d.ts

@@ -1,2 +1,5 @@
-import { ParseFromUrlOptions, TokenResponse } from '../types';
+import { ParseFromUrlOptions, TokenResponse, OAuthResponse } from '../types';
+export declare function getResponseMode(sdk: any): 'query' | 'fragment';
+export declare function parseOAuthResponseFromUrl(sdk: any, options: string | ParseFromUrlOptions): OAuthResponse;
+export declare function cleanOAuthResponseFromUrl(sdk: any, options: ParseFromUrlOptions): void;
 export declare function parseFromUrl(sdk: any, options: string | ParseFromUrlOptions): Promise<TokenResponse>;

package/lib/oidc/renewTokens.d.ts

@@ -1,14 +1,2 @@
-/*!
- * 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 { TokenParams, Tokens } from '../types';
 export declare function renewTokens(sdk: any, options: TokenParams): Promise<Tokens>;

package/lib/oidc/util/loginRedirect.d.ts

@@ -27,4 +27,4 @@ export declare function isLoginRedirect(sdk: OktaAuth): boolean;
  * Check if error=interaction_required has been passed back in the url, which happens in
  * the social auth IDP redirect flow.
  */
-export declare function isInteractionRequired(sdk: OktaAuth): boolean;
+export declare function isInteractionRequired(sdk: OktaAuth, hashOrSearch?: string): boolean;

package/lib/types/AuthState.d.ts

@@ -16,6 +16,7 @@ export interface AuthState {
     refreshToken?: RefreshToken;
     isAuthenticated?: boolean;
     error?: Error;
+    [otherOption: string]: unknown;
 }
 export interface AuthStateLogOptions {
     event?: string;

package/lib/types/OktaAuthOptions.d.ts

@@ -12,10 +12,11 @@
 import { StorageManagerOptions, StorageUtil } from './Storage';
 import { CookieOptions } from './Cookies';
 import { HttpRequestClient } from './http';
-import { OktaAuth } from './';
 import { AuthState } from './AuthState';
 import { TransactionManagerOptions } from './Transaction';
 import { SimpleStorage } from './Storage';
+import { FlowIdentifier } from '../idx/types';
+import OktaAuth from '../OktaAuth';
 export interface TokenManagerOptions {
     autoRenew?: boolean;
     autoRemove?: boolean;
@@ -64,5 +65,6 @@ export interface OktaAuthOptions extends CustomUrls {
     devMode?: boolean;
     storageManager?: StorageManagerOptions;
     transactionManager?: TransactionManagerOptions;
+    flow?: FlowIdentifier;
     clientSecret?: string;
 }