@okta/okta-auth-js 6.8.1 → 7.0.0

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

@@ -0,0 +1,23 @@
+/*!
+ * 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 { OktaAuthHttpInterface } from '../http/types';
+import { OktaAuthStorageOptions } from '../storage/types';
+import { AuthnTransactionAPI } from './types';
+import { OktaAuthBaseInterface } from '../base/types';
+export declare function transactionStatus(sdk: OktaAuthHttpInterface, args: any): Promise<any>;
+export declare function resumeTransaction(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, args: any): Promise<import("./types").AuthnTransaction>;
+export declare function introspectAuthn(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, args: any): Promise<import("./types").AuthnTransaction>;
+export declare function transactionStep(sdk: OktaAuthHttpInterface, args: any): Promise<any>;
+export declare function transactionExists(sdk: OktaAuthBaseInterface<OktaAuthStorageOptions>): boolean;
+export declare function postToTransaction(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, url: string, args: any, options?: any): Promise<import("./types").AuthnTransaction>;
+export declare function getSavedStateToken(sdk: OktaAuthBaseInterface<OktaAuthStorageOptions>): string;

package/types/lib/authn/factory.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.
+ *
+ */
+import { OktaAuthHttpInterface } from '../http/types';
+import { AuthnTransactionAPI } from './types';
+export declare function createAuthnTransactionAPI(sdk: OktaAuthHttpInterface): AuthnTransactionAPI;

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

@@ -0,0 +1,3 @@
+export * from './factory';
+export * from './mixin';
+export * from './types';

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

@@ -0,0 +1,16 @@
+/*!
+ * 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 { OktaAuthTxInterface } from './types';
+import { StorageManagerInterface } from '../storage/types';
+import { OktaAuthHttpInterface, OktaAuthHttpOptions } from '../http/types';
+import { OktaAuthConstructor } from '../base/types';
+export declare function mixinAuthn<S extends StorageManagerInterface = StorageManagerInterface, O extends OktaAuthHttpOptions = OktaAuthHttpOptions, TBase extends OktaAuthConstructor<OktaAuthHttpInterface<S, O>> = OktaAuthConstructor<OktaAuthHttpInterface<S, O>>>(Base: TBase): TBase & OktaAuthConstructor<OktaAuthTxInterface<S, O>>;

package/types/lib/authn/types.d.ts

@@ -0,0 +1,101 @@
+import { StorageManagerInterface } from '../storage/types';
+import { RequestData, RequestOptions, OktaAuthHttpInterface, OktaAuthHttpOptions } from '../http/types';
+export interface AuthnTransactionLink {
+    name?: string;
+    type: string;
+    href: string;
+    hints?: {
+        allow?: string[];
+    };
+}
+export interface AuthnTransactionState {
+    status: string;
+    stateToken?: string;
+    type?: string;
+    expiresAt?: string;
+    relayState?: string;
+    factorResult?: string;
+    factorType?: string;
+    recoveryToken?: string;
+    recoveryType?: string;
+    autoPush?: boolean | (() => boolean);
+    rememberDevice?: boolean | (() => boolean);
+    profile?: {
+        updatePhone?: boolean;
+    };
+    _links?: Record<string, AuthnTransactionLink>;
+}
+export declare type AuthnTransactionFunction = (obj?: any) => Promise<AuthnTransaction>;
+export interface AuthnTransactionFunctions {
+    next?: AuthnTransactionFunction;
+    cancel?: AuthnTransactionFunction;
+    skip?: AuthnTransactionFunction;
+    unlock?: AuthnTransactionFunction;
+    changePassword?: AuthnTransactionFunction;
+    resetPassword?: AuthnTransactionFunction;
+    answer?: AuthnTransactionFunction;
+    recovery?: AuthnTransactionFunction;
+    verify?: AuthnTransactionFunction;
+    resend?: AuthnTransactionFunction;
+    activate?: AuthnTransactionFunction;
+    poll?: AuthnTransactionFunction;
+    prev?: AuthnTransactionFunction;
+}
+export interface AuthnTransaction extends AuthnTransactionState, AuthnTransactionFunctions {
+    sessionToken?: string;
+    user?: Record<string, any>;
+    factor?: Record<string, any>;
+    factors?: Array<Record<string, any>>;
+    policy?: Record<string, any>;
+    scopes?: Array<Record<string, any>>;
+    target?: Record<string, any>;
+    authentication?: Record<string, any>;
+}
+export interface AuthnTransactionAPI {
+    exists: () => boolean;
+    status: (args?: object) => Promise<object>;
+    resume: (args?: object) => Promise<AuthnTransaction>;
+    introspect: (args?: object) => Promise<AuthnTransaction>;
+    createTransaction: (res?: AuthnTransactionState) => AuthnTransaction;
+    postToTransaction: (url: string, args?: RequestData, options?: RequestOptions) => Promise<AuthnTransaction>;
+}
+export interface SigninOptions {
+    relayState?: string;
+    context?: {
+        deviceToken?: string;
+    };
+    sendFingerprint?: boolean;
+    stateToken?: string;
+    username?: string;
+    password?: string;
+}
+export interface SigninWithCredentialsOptions extends SigninOptions {
+    username: string;
+    password: string;
+}
+export interface SigninAPI {
+    signIn(opts: SigninOptions): Promise<AuthnTransaction>;
+    signInWithCredentials(opts: SigninWithCredentialsOptions): Promise<AuthnTransaction>;
+}
+export interface ForgotPasswordOptions {
+    username: string;
+    factorType: 'SMS' | 'EMAIL' | 'CALL';
+    relayState?: string;
+}
+export interface VerifyRecoveryTokenOptions {
+    recoveryToken: string;
+}
+export interface AuthnAPI extends SigninAPI {
+    forgotPassword(opts: any): Promise<AuthnTransaction>;
+    unlockAccount(opts: ForgotPasswordOptions): Promise<AuthnTransaction>;
+    verifyRecoveryToken(opts: VerifyRecoveryTokenOptions): Promise<AuthnTransaction>;
+}
+export interface FingerprintOptions {
+    timeout?: number;
+}
+export declare type FingerprintAPI = (options?: FingerprintOptions) => Promise<string>;
+export interface OktaAuthTxInterface<S extends StorageManagerInterface = StorageManagerInterface, O extends OktaAuthHttpOptions = OktaAuthHttpOptions> extends OktaAuthHttpInterface<S, O>, AuthnAPI {
+    tx: AuthnTransactionAPI;
+    authn: AuthnTransactionAPI;
+    fingerprint: FingerprintAPI;
+}

package/types/lib/authn/util/flattenEmbedded.d.ts

@@ -0,0 +1,3 @@
+import { OktaAuthHttpInterface } from '../../http/types';
+import { AuthnTransactionAPI } from '../types';
+export declare function flattenEmbedded(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, res: any, obj: any, ref: any): any;

package/types/lib/authn/util/link2fn.d.ts

@@ -0,0 +1,3 @@
+import { OktaAuthHttpInterface } from '../../http/types';
+import { AuthnTransactionAPI } from '../types';
+export declare function link2fn(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, res: any, obj: any, link: any, ref: any): any;

package/types/lib/authn/util/links2fns.d.ts

@@ -0,0 +1,3 @@
+import { OktaAuthHttpInterface } from '../../http/types';
+import { AuthnTransactionFunctions, AuthnTransactionAPI } from '../types';
+export declare function links2fns(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, res: any, obj: any, ref: any): AuthnTransactionFunctions;

package/types/lib/authn/util/poll.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * 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 { AuthnTransactionState } from '../types';
+interface PollOptions {
+    delay?: number;
+    rememberDevice?: boolean;
+    autoPush?: boolean;
+    transactionCallBack?: (AuthnTransactionState: any) => void;
+}
+export declare function getPollFn(sdk: any, res: AuthnTransactionState, ref: any): (options: PollOptions | number) => any;
+export {};

package/types/lib/authn/util/stateToken.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.
+ *
+ */
+import { AuthnTransactionState } from '../types';
+export declare function addStateToken(res: any, options?: any): AuthnTransactionState;
+export declare function getStateToken(res: any): AuthnTransactionState;

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

@@ -0,0 +1,2 @@
+import { OktaAuthConstructor, OktaAuthBaseInterface, OktaAuthBaseOptions, OktaAuthOptionsConstructor } from './types';
+export declare function createOktaAuthBase<O extends OktaAuthBaseOptions = OktaAuthBaseOptions>(OptionsConstructor: OktaAuthOptionsConstructor<O>): OktaAuthConstructor<OktaAuthBaseInterface<O>>;

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

@@ -0,0 +1,3 @@
+export * from './factory';
+export * from './options';
+export * from './types';

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

@@ -0,0 +1,16 @@
+/*!
+ * 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 declare function createBaseOptionsConstructor(): {
+    new (args: any): {
+        devMode: boolean;
+    };
+};

package/types/lib/base/types.d.ts

@@ -0,0 +1,43 @@
+/*!
+ * 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 * as constants from '../constants';
+export declare class EventEmitter {
+    on(event: string, callback: (...args: any[]) => any, ctx?: any): EventEmitter;
+    once(event: string, callback: (...args: any[]) => any, ctx?: any): EventEmitter;
+    emit(event: string, ...args: any[]): EventEmitter;
+    off(event: string, callback?: (...args: any[]) => any): EventEmitter;
+}
+export interface FeaturesAPI {
+    isLocalhost(): boolean;
+    isHTTPS(): boolean;
+    isPopupPostMessageSupported(): boolean;
+    hasTextEncoder(): boolean;
+    isTokenVerifySupported(): boolean;
+    isPKCESupported(): boolean;
+    isIE11OrLess(): boolean;
+}
+export interface OktaAuthBaseOptions {
+    devMode?: boolean;
+}
+export interface OktaAuthOptionsConstructor<O extends OktaAuthBaseOptions = OktaAuthBaseOptions> {
+    new (args: any): O;
+}
+export interface OktaAuthBaseInterface<O extends OktaAuthBaseOptions = OktaAuthBaseOptions> {
+    options: O;
+    emitter: EventEmitter;
+    features: FeaturesAPI;
+}
+export interface OktaAuthConstructor<I extends OktaAuthBaseInterface = OktaAuthBaseInterface> {
+    new (...args: any[]): I;
+    features: FeaturesAPI;
+    constants: typeof constants;
+}

package/types/lib/browser/browserStorage.d.ts

@@ -0,0 +1,33 @@
+/*!
+ * 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 Cookies from 'js-cookie';
+import { StorageOptions, SimpleStorage, StorageType, StorageUtil } from '../storage/types';
+export interface CookieStorage extends SimpleStorage {
+    setItem(key: string, value: any, expiresAt?: string | null): void;
+    getItem(key?: string): any;
+    removeItem(key: string): any;
+}
+export interface BrowserStorageUtil extends StorageUtil {
+    browserHasLocalStorage(): boolean;
+    browserHasSessionStorage(): boolean;
+    getStorageByType(storageType: StorageType, options: StorageOptions): SimpleStorage;
+    getLocalStorage(): Storage;
+    getSessionStorage(): Storage;
+    getInMemoryStorage(): SimpleStorage;
+    getCookieStorage(options?: StorageOptions): CookieStorage;
+    testStorage(storage: any): boolean;
+    storage: Cookies;
+    inMemoryStore: Record<string, unknown>;
+}
+declare var storageUtil: BrowserStorageUtil;
+export default storageUtil;

package/types/lib/browser/fingerprint.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * 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 { FingerprintOptions } from '../authn/types';
+import { OktaAuthHttpInterface } from '../http/types';
+export default function fingerprint(sdk: OktaAuthHttpInterface, options?: FingerprintOptions): Promise<string>;

package/types/lib/constants.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * 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 declare const STATE_TOKEN_KEY_NAME = "oktaStateToken";
+export declare const DEFAULT_POLLING_DELAY = 500;
+export declare const DEFAULT_MAX_CLOCK_SKEW = 300;
+export declare const DEFAULT_CACHE_DURATION = 86400;
+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";
+export declare const REFRESH_TOKEN_STORAGE_KEY = "refreshToken";
+export declare const REFERRER_PATH_STORAGE_KEY = "referrerPath";
+export declare const MIN_VERIFIER_LENGTH = 43;
+export declare const MAX_VERIFIER_LENGTH = 128;
+export declare const DEFAULT_CODE_CHALLENGE_METHOD = "S256";
+export declare const IDX_API_VERSION = "1.0.0";

package/types/lib/core/AuthStateManager.d.ts

@@ -0,0 +1,33 @@
+/*!
+ * 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 { OAuthStorageManagerInterface, OAuthTransactionMeta, OktaAuthOAuthInterface } from '../oidc';
+import { AuthState, AuthStateLogOptions, OktaAuthCoreOptions } from './types';
+import { PromiseQueue } from '../util';
+export declare const INITIAL_AUTH_STATE: null;
+export declare class AuthStateManager<M extends OAuthTransactionMeta, S extends OAuthStorageManagerInterface<M>, O extends OktaAuthCoreOptions> {
+    _sdk: OktaAuthOAuthInterface<M, S, O>;
+    _pending: {
+        updateAuthStatePromise: any;
+        canceledTimes: number;
+    };
+    _authState: AuthState | null;
+    _prevAuthState: AuthState | null;
+    _logOptions: AuthStateLogOptions;
+    _transformQueue: PromiseQueue;
+    constructor(sdk: OktaAuthOAuthInterface<M, S, O>);
+    _setLogOptions(options: any): void;
+    getAuthState(): AuthState | null;
+    getPreviousAuthState(): AuthState | null;
+    updateAuthState(): Promise<AuthState>;
+    subscribe(handler: any): void;
+    unsubscribe(handler?: any): void;
+}

package/types/lib/core/ServiceManager/browser.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * 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 { OAuthTransactionMeta, OAuthStorageManagerInterface } from '../../oidc';
+import { ServiceManagerInterface, ServiceInterface, ServiceManagerOptions, OktaAuthCoreInterface, OktaAuthCoreOptions } from '../types';
+export declare class ServiceManager<M extends OAuthTransactionMeta, S extends OAuthStorageManagerInterface<M>, O extends OktaAuthCoreOptions> implements ServiceManagerInterface {
+    private sdk;
+    private options;
+    private services;
+    private started;
+    private static knownServices;
+    private static defaultOptions;
+    constructor(sdk: OktaAuthCoreInterface<M, S, O>, options?: ServiceManagerOptions);
+    private onLeader;
+    isLeader(): boolean;
+    isLeaderRequired(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getService(name: string): ServiceInterface | undefined;
+    private startServices;
+    private stopServices;
+    private canStartService;
+    private createService;
+}

package/types/lib/core/ServiceManager/node.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * 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 { OAuthTransactionMeta, OAuthStorageManagerInterface } from '../../oidc';
+import { ServiceManagerInterface, ServiceInterface, ServiceManagerOptions, OktaAuthCoreInterface, OktaAuthCoreOptions } from '../types';
+export declare class ServiceManager<M extends OAuthTransactionMeta, S extends OAuthStorageManagerInterface<M>, O extends OktaAuthCoreOptions> implements ServiceManagerInterface {
+    private sdk;
+    private options;
+    constructor(sdk: OktaAuthCoreInterface<M, S, O>, options?: ServiceManagerOptions);
+    isLeader(): boolean;
+    isLeaderRequired(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getService(name: string): ServiceInterface | undefined;
+}

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

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

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

@@ -0,0 +1,7 @@
+export * from './AuthStateManager';
+export * from './options';
+export * from './factory';
+export * from './mixin';
+export * from './storage';
+export * from './types';
+export * from './ServiceManager';

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

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

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

@@ -0,0 +1,50 @@
+/*!
+ * 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 { AuthState, OktaAuthCoreInterface, ServiceManagerOptions } from './types';
+export declare function createCoreOptionsConstructor(): {
+    new (options: any): {
+        services: ServiceManagerOptions;
+        transformAuthState: (oktaAuth: OktaAuthCoreInterface, authState: AuthState) => Promise<AuthState>;
+        issuer: string;
+        authorizeUrl: string;
+        userinfoUrl: string;
+        tokenUrl: string;
+        revokeUrl: string;
+        logoutUrl: string;
+        pkce: boolean;
+        clientId: string;
+        redirectUri: string;
+        responseType: import("../oidc").OAuthResponseType | import("../oidc").OAuthResponseType[];
+        responseMode: import("../oidc").OAuthResponseMode;
+        state: string;
+        scopes: string[];
+        ignoreSignature: boolean;
+        codeChallenge: string;
+        codeChallengeMethod: string;
+        tokenManager: import("../oidc").TokenManagerOptions;
+        postLogoutRedirectUri: string;
+        restoreOriginalUri: (oktaAuth: import("../oidc").OktaAuthOAuthInterface<import("../oidc").PKCETransactionMeta, import("../oidc").OAuthStorageManagerInterface<import("../oidc").PKCETransactionMeta>, import("../oidc").OktaAuthOAuthOptions, import("../oidc").TransactionManagerInterface>, originalUri?: string | undefined) => Promise<void>;
+        transactionManager: import("../oidc").TransactionManagerOptions;
+        clientSecret: string;
+        setLocation: import("../oidc").SetLocationFunction;
+        ignoreLifetime: boolean;
+        maxClockSkew: number;
+        transformErrorXHR: (xhr: object) => any;
+        headers: object;
+        httpRequestClient: import("../http").HttpRequestClient;
+        httpRequestInterceptors: ((request: import("../http").RequestOptions) => void)[];
+        cookies: import("../storage").CookieOptions;
+        storageUtil: import("../storage").StorageUtil;
+        storageManager: import("../storage").StorageManagerOptions;
+        devMode: boolean;
+    };
+};

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

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

package/types/lib/core/types/AuthState.d.ts

@@ -0,0 +1,33 @@
+/*!
+ * 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 { AccessToken, IDToken, RefreshToken, Token } from '../../oidc/types/Token';
+export interface AuthState {
+    accessToken?: AccessToken;
+    idToken?: IDToken;
+    refreshToken?: RefreshToken;
+    isAuthenticated?: boolean;
+    error?: Error;
+    [otherOption: string]: unknown;
+}
+export interface AuthStateLogOptions {
+    event?: string;
+    key?: string;
+    token?: Token;
+}
+export declare type AuthStateEventHandler = (authState: AuthState) => void;
+export interface AuthStateManagerInterface {
+    getAuthState(): AuthState | null;
+    getPreviousAuthState(): AuthState | null;
+    updateAuthState(): Promise<AuthState>;
+    subscribe(handler: AuthStateEventHandler): void;
+    unsubscribe(handler?: AuthStateEventHandler): void;
+}

package/types/lib/core/types/Service.d.ts

@@ -0,0 +1,27 @@
+export interface ServiceInterface {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isStarted(): boolean;
+    canStart(): boolean;
+    requiresLeadership(): boolean;
+}
+export interface ServiceManagerInterface {
+    isLeaderRequired(): boolean;
+    isLeader(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getService(name: string): ServiceInterface | undefined;
+}
+export interface AutoRenewServiceOptions {
+    autoRenew?: boolean;
+    autoRemove?: boolean;
+}
+export interface SyncStorageServiceOptions {
+    syncStorage?: boolean;
+    syncChannelName?: string;
+}
+export interface LeaderElectionServiceOptions {
+    electionChannelName?: string;
+    broadcastChannelName?: string;
+}
+export declare type ServiceManagerOptions = AutoRenewServiceOptions & SyncStorageServiceOptions & LeaderElectionServiceOptions;

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

@@ -0,0 +1,15 @@
+import { OAuthStorageManagerInterface, OktaAuthOAuthInterface, OktaAuthOAuthOptions, PKCETransactionMeta, Tokens, TransactionManagerInterface } from '../../oidc/types';
+import { ServiceManagerInterface, ServiceManagerOptions } from './Service';
+import { AuthState, AuthStateManagerInterface } from './AuthState';
+export interface OktaAuthCoreOptions extends OktaAuthOAuthOptions {
+    services?: ServiceManagerOptions;
+    transformAuthState?: (oktaAuth: OktaAuthCoreInterface, authState: AuthState) => Promise<AuthState>;
+}
+export declare type CoreStorageManagerInterface<M extends PKCETransactionMeta = PKCETransactionMeta> = OAuthStorageManagerInterface<M>;
+export interface OktaAuthCoreInterface<M extends PKCETransactionMeta = PKCETransactionMeta, S extends CoreStorageManagerInterface<M> = CoreStorageManagerInterface<M>, O extends OktaAuthCoreOptions = OktaAuthCoreOptions, TM extends TransactionManagerInterface = TransactionManagerInterface> extends OktaAuthOAuthInterface<M, S, O, TM> {
+    serviceManager: ServiceManagerInterface;
+    authStateManager: AuthStateManagerInterface;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleLoginRedirect(tokens?: Tokens, originalUri?: string): Promise<void>;
+}