@okta/okta-auth-js 6.8.1 → 7.0.0

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

@@ -0,0 +1,117 @@
+/*!
+ * 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 { JWTObject } from './JWT';
+import { OAuthTransactionMeta, PKCETransactionMeta } from './meta';
+import { CustomUrls, OktaAuthOAuthOptions, SigninWithRedirectOptions, TokenParams } from './options';
+import { OAuthStorageManagerInterface } from './storage';
+import { AccessToken, IDToken, RefreshToken, RevocableToken, Token, Tokens } from './Token';
+import { TokenManagerInterface } from './TokenManager';
+import { CustomUserClaims, UserClaims } from './UserClaims';
+import { TransactionManagerInterface } from './TransactionManager';
+import { OktaAuthSessionInterface } from '../../session/types';
+export interface PopupParams {
+    popupTitle?: string;
+    popupWindow?: Window;
+}
+export interface TokenResponse {
+    tokens: Tokens;
+    state: string;
+    code?: string;
+}
+export interface ParseFromUrlOptions {
+    url?: string;
+    responseMode?: string;
+}
+export declare type ParseFromUrlFunction = (options?: string | ParseFromUrlOptions) => Promise<TokenResponse>;
+export interface ParseFromUrlInterface extends ParseFromUrlFunction {
+    _getDocument: () => Document;
+    _getLocation: () => Location;
+    _getHistory: () => History;
+}
+export declare type GetWithRedirectFunction = (params?: TokenParams) => Promise<void>;
+export declare type SetLocationFunction = (loc: string) => void;
+export interface GetWithRedirectAPI extends GetWithRedirectFunction {
+    _setLocation: SetLocationFunction;
+}
+export interface BaseTokenAPI {
+    decode(token: string): JWTObject;
+    prepareTokenParams(params?: TokenParams): Promise<TokenParams>;
+    exchangeCodeForTokens(params: TokenParams, urls?: CustomUrls): Promise<TokenResponse>;
+}
+export interface TokenAPI extends BaseTokenAPI {
+    getUserInfo<S extends CustomUserClaims = CustomUserClaims>(accessToken?: AccessToken, idToken?: IDToken): Promise<UserClaims<S>>;
+    getWithRedirect: GetWithRedirectAPI;
+    parseFromUrl: ParseFromUrlInterface;
+    getWithoutPrompt(params?: TokenParams): Promise<TokenResponse>;
+    getWithPopup(params?: TokenParams): Promise<TokenResponse>;
+    revoke(token: RevocableToken): Promise<object>;
+    renew(token: Token): Promise<Token | undefined>;
+    renewTokens(options?: TokenParams): Promise<Tokens>;
+    renewTokensWithRefresh(tokenParams: TokenParams, refreshTokenObject: RefreshToken): Promise<Tokens>;
+    verify(token: IDToken, params?: object): Promise<IDToken>;
+    isLoginRedirect(): boolean;
+}
+export interface TokenVerifyParams {
+    clientId: string;
+    issuer: string;
+    ignoreSignature?: boolean;
+    nonce?: string;
+    accessToken?: string;
+}
+export interface IDTokenAPI {
+    authorize: {
+        _getLocationHref: () => string;
+    };
+}
+export interface PkceAPI {
+    DEFAULT_CODE_CHALLENGE_METHOD: string;
+    generateVerifier(prefix: string): string;
+    computeChallenge(str: string): PromiseLike<any>;
+}
+export interface IsAuthenticatedOptions {
+    onExpiredToken?: 'renew' | 'remove' | 'none';
+}
+export interface SignoutRedirectUrlOptions {
+    postLogoutRedirectUri?: string;
+    idToken?: IDToken;
+    state?: string;
+}
+export interface SignoutOptions extends SignoutRedirectUrlOptions {
+    revokeAccessToken?: boolean;
+    revokeRefreshToken?: boolean;
+    accessToken?: AccessToken;
+    refreshToken?: RefreshToken;
+    clearTokensBeforeRedirect?: boolean;
+}
+export interface OriginalUriApi {
+    getOriginalUri(state?: string): string | undefined;
+    setOriginalUri(originalUri: string, state?: string): void;
+    removeOriginalUri(state?: string): void;
+}
+export interface OktaAuthOAuthInterface<M extends OAuthTransactionMeta = PKCETransactionMeta, S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>, O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions, TM extends TransactionManagerInterface = TransactionManagerInterface> extends OktaAuthSessionInterface<S, O>, OriginalUriApi {
+    token: TokenAPI;
+    tokenManager: TokenManagerInterface;
+    pkce: PkceAPI;
+    transactionManager: TM;
+    isPKCE(): boolean;
+    getIdToken(): string | undefined;
+    getAccessToken(): string | undefined;
+    getRefreshToken(): string | undefined;
+    isAuthenticated(options?: IsAuthenticatedOptions): Promise<boolean>;
+    signOut(opts?: SignoutOptions): Promise<void>;
+    isLoginRedirect(): boolean;
+    storeTokensFromRedirect(): Promise<void>;
+    getUser<T extends CustomUserClaims = CustomUserClaims>(): Promise<UserClaims<T>>;
+    signInWithRedirect(opts?: SigninWithRedirectOptions): Promise<void>;
+    revokeAccessToken(accessToken?: AccessToken): Promise<unknown>;
+    revokeRefreshToken(refreshToken?: RefreshToken): Promise<unknown>;
+}

package/types/lib/oidc/types/index.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.
+ */
+export * from './api';
+export * from './JWT';
+export * from './meta';
+export * from './options';
+export * from './proto';
+export * from './storage';
+export * from './Token';
+export * from './TokenManager';
+export * from './Transaction';
+export * from './TransactionManager';
+export * from './UserClaims';

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

@@ -0,0 +1,21 @@
+/*!
+ * 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 { CustomUrls, TokenParams } from './options';
+export interface OAuthTransactionMeta extends Pick<TokenParams, 'issuer' | 'clientId' | 'redirectUri' | 'responseType' | 'responseMode' | 'scopes' | 'state' | 'pkce' | 'ignoreSignature' | 'nonce'> {
+    urls: CustomUrls;
+    originalUri?: string;
+}
+export interface PKCETransactionMeta extends OAuthTransactionMeta, Pick<TokenParams, 'codeChallenge' | 'codeChallengeMethod' | 'codeVerifier'> {
+}
+export interface TransactionMetaOptions extends Pick<PKCETransactionMeta, 'state' | 'codeChallenge' | 'codeChallengeMethod' | 'codeVerifier'> {
+    muteWarning?: boolean;
+}

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

@@ -0,0 +1,77 @@
+/*!
+ * 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 { OktaAuthOptionsConstructor } from '../../base/types';
+import { OktaAuthHttpOptions } from '../../http/types';
+import { SimpleStorage } from '../../storage/types';
+import { OktaAuthOAuthInterface, SetLocationFunction } from './api';
+import { OAuthResponseMode, OAuthResponseType } from './proto';
+import { TransactionManagerOptions } from './Transaction';
+export interface CustomUrls {
+    issuer?: string;
+    authorizeUrl?: string;
+    userinfoUrl?: string;
+    tokenUrl?: string;
+    revokeUrl?: string;
+    logoutUrl?: string;
+}
+export interface TokenParams extends CustomUrls {
+    pkce?: boolean;
+    clientId?: string;
+    redirectUri?: string;
+    responseType?: OAuthResponseType | OAuthResponseType[];
+    responseMode?: OAuthResponseMode;
+    state?: string;
+    nonce?: string;
+    scopes?: string[];
+    display?: string;
+    ignoreSignature?: boolean;
+    codeVerifier?: string;
+    authorizationCode?: string;
+    codeChallenge?: string;
+    codeChallengeMethod?: string;
+    interactionCode?: string;
+    idp?: string;
+    idpScope?: string | string[];
+    loginHint?: string;
+    maxAge?: string | number;
+    prompt?: string;
+    sessionToken?: string;
+    timeout?: number;
+    extraParams?: {
+        [propName: string]: string;
+    };
+    popupTitle?: string;
+}
+export interface TokenManagerOptions {
+    autoRenew?: boolean;
+    autoRemove?: boolean;
+    clearPendingRemoveTokens?: boolean;
+    secure?: boolean;
+    storage?: string | SimpleStorage;
+    storageKey?: string;
+    expireEarlySeconds?: number;
+    syncStorage?: boolean;
+}
+export interface SigninWithRedirectOptions extends TokenParams {
+    originalUri?: string;
+}
+export interface OktaAuthOAuthOptions extends OktaAuthHttpOptions, CustomUrls, Pick<TokenParams, 'issuer' | 'clientId' | 'redirectUri' | 'responseType' | 'responseMode' | 'scopes' | 'state' | 'pkce' | 'ignoreSignature' | 'codeChallenge' | 'codeChallengeMethod'> {
+    ignoreLifetime?: boolean;
+    tokenManager?: TokenManagerOptions;
+    postLogoutRedirectUri?: string;
+    maxClockSkew?: number;
+    restoreOriginalUri?: (oktaAuth: OktaAuthOAuthInterface, originalUri?: string) => Promise<void>;
+    transactionManager?: TransactionManagerOptions;
+    clientSecret?: string;
+    setLocation?: SetLocationFunction;
+}
+export declare type OktaAuthOauthOptionsConstructor = OktaAuthOptionsConstructor<OktaAuthOAuthOptions>;

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

@@ -0,0 +1,13 @@
+import { StorageManagerConstructor, StorageManagerInterface, StorageOptions, StorageProvider } from '../../storage/types';
+import { OAuthTransactionMeta, PKCETransactionMeta } from './meta';
+export interface TransactionStorage<M extends OAuthTransactionMeta = OAuthTransactionMeta> extends StorageProvider {
+    setStorage(obj: M): void;
+    getStorage(): M;
+}
+export interface OAuthStorageManagerInterface<M extends OAuthTransactionMeta = PKCETransactionMeta> extends StorageManagerInterface {
+    getTransactionStorage(options?: StorageOptions): TransactionStorage<M>;
+    getSharedTansactionStorage(options?: StorageOptions): TransactionStorage<M>;
+    getOriginalUriStorage(options?: StorageOptions): TransactionStorage<M>;
+    getTokenStorage(options?: StorageOptions): StorageProvider;
+}
+export declare type OAuthStorageManagerConstructor<M extends OAuthTransactionMeta = PKCETransactionMeta> = StorageManagerConstructor<OAuthStorageManagerInterface<M>>;

package/types/lib/oidc/util/browser.d.ts

@@ -0,0 +1,6 @@
+import { OktaAuthOAuthInterface } from '../types';
+export declare function addListener(eventTarget: any, name: any, fn: any): void;
+export declare function removeListener(eventTarget: any, name: any, fn: any): void;
+export declare function loadFrame(src: any): HTMLIFrameElement;
+export declare function loadPopup(src: any, options: any): Window | null;
+export declare function addPostMessageListener(sdk: OktaAuthOAuthInterface, timeout: any, state: any): Promise<unknown>;

package/types/lib/oidc/util/defaultTokenParams.d.ts

@@ -0,0 +1,2 @@
+import { OktaAuthOAuthInterface, TokenParams } from '../types';
+export declare function getDefaultTokenParams(sdk: OktaAuthOAuthInterface): TokenParams;

package/types/lib/oidc/util/errors.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 { OktaAuthOAuthInterface } from '../types';
+export declare function isInteractionRequiredError(error: Error): boolean;
+export declare function isAuthorizationCodeError(sdk: OktaAuthOAuthInterface, error: Error): boolean | undefined;
+export declare function isRefreshTokenInvalidError(error: unknown): boolean;

package/types/lib/oidc/util/loginRedirect.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.
+ *
+ */
+import { OktaAuthOAuthOptions, OktaAuthOAuthInterface } from '../types';
+export declare function hasTokensInHash(hash: string): boolean;
+export declare function hasAuthorizationCode(hashOrSearch: string): boolean;
+export declare function hasInteractionCode(hashOrSearch: string): boolean;
+export declare function hasErrorInUrl(hashOrSearch: string): boolean;
+export declare function isRedirectUri(uri: string, sdk: OktaAuthOAuthInterface): boolean;
+export declare function isCodeFlow(options: OktaAuthOAuthOptions): boolean;
+export declare function getHashOrSearch(options: OktaAuthOAuthOptions): string;
+/**
+ * Check if tokens or a code have been passed back into the url, which happens in
+ * the OIDC (including social auth IDP) redirect flow.
+ */
+export declare function isLoginRedirect(sdk: OktaAuthOAuthInterface): 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: OktaAuthOAuthInterface, hashOrSearch?: string): boolean;

package/types/lib/oidc/util/oauth.d.ts

@@ -0,0 +1,6 @@
+import { OktaAuthOAuthInterface, CustomUrls } from '../types';
+export declare function generateState(): string;
+export declare function generateNonce(): string;
+export declare function getOAuthBaseUrl(sdk: OktaAuthOAuthInterface, options?: CustomUrls): any;
+export declare function getOAuthDomain(sdk: OktaAuthOAuthInterface, options?: CustomUrls): any;
+export declare function getOAuthUrls(sdk: OktaAuthOAuthInterface, options?: CustomUrls): CustomUrls;

package/types/lib/oidc/util/oauthMeta.d.ts

@@ -0,0 +1,2 @@
+import { OAuthTransactionMeta, OktaAuthOAuthInterface, PKCETransactionMeta, TokenParams } from '../types';
+export declare function createOAuthMeta(sdk: OktaAuthOAuthInterface, tokenParams: TokenParams): OAuthTransactionMeta | PKCETransactionMeta;

package/types/lib/oidc/util/prepareTokenParams.d.ts

@@ -0,0 +1,6 @@
+import { OktaAuthOAuthInterface, TokenParams } from '../types';
+import { OktaAuthBaseInterface } from '../../base/types';
+export declare function assertPKCESupport(sdk: OktaAuthBaseInterface): void;
+export declare function validateCodeChallengeMethod(sdk: OktaAuthOAuthInterface, codeChallengeMethod?: string): Promise<string>;
+export declare function preparePKCE(sdk: OktaAuthOAuthInterface, tokenParams: TokenParams): Promise<TokenParams>;
+export declare function prepareTokenParams(sdk: OktaAuthOAuthInterface, tokenParams?: TokenParams): Promise<TokenParams>;

package/types/lib/oidc/util/refreshToken.d.ts

@@ -0,0 +1,3 @@
+import { RefreshToken } from '../types';
+export declare function isSameRefreshToken(a: RefreshToken, b: RefreshToken): boolean;
+export declare function isRefreshTokenError(err: Error): boolean;

package/types/lib/oidc/util/sharedStorage.d.ts

@@ -0,0 +1,5 @@
+import { OAuthStorageManagerInterface, OAuthTransactionMeta } from '../types';
+export declare function pruneSharedStorage<M extends OAuthTransactionMeta>(storageManager: OAuthStorageManagerInterface<M>): void;
+export declare function saveTransactionToSharedStorage<M extends OAuthTransactionMeta>(storageManager: OAuthStorageManagerInterface<M>, state: string, meta: M): void;
+export declare function loadTransactionFromSharedStorage<M extends OAuthTransactionMeta>(storageManager: OAuthStorageManagerInterface<M>, state: string): any;
+export declare function clearTransactionFromSharedStorage<M extends OAuthTransactionMeta>(storageManager: OAuthStorageManagerInterface<M>, state: string): void;

package/types/lib/oidc/util/validateClaims.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 { OktaAuthOAuthInterface, TokenVerifyParams, UserClaims } from '../../oidc/types';
+export declare function validateClaims(sdk: OktaAuthOAuthInterface, claims: UserClaims, validationParams: TokenVerifyParams): void;

package/types/lib/oidc/util/validateToken.d.ts

@@ -0,0 +1,2 @@
+import { Token, TokenType } from '../../oidc/types';
+export declare function validateToken(token: Token, type?: TokenType): void;

package/types/lib/oidc/verifyToken.d.ts

@@ -0,0 +1,2 @@
+import { IDToken, OktaAuthOAuthInterface, TokenVerifyParams } from '../oidc/types';
+export declare function verifyToken(sdk: OktaAuthOAuthInterface, token: IDToken, validationParams: TokenVerifyParams): Promise<IDToken>;

package/types/lib/server/serverStorage.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright (c) 2018-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 { SimpleStorage, StorageType, StorageUtil, Cookies } from '../storage/types';
+declare class ServerStorage implements StorageUtil {
+    nodeCache: any;
+    storage: Cookies;
+    constructor(nodeCache: any);
+    testStorageType(storageType: StorageType): boolean;
+    getStorageByType(storageType: StorageType): SimpleStorage;
+    findStorageType(): StorageType;
+    getStorage(): SimpleStorage;
+}
+declare const _default: ServerStorage;
+export default _default;

package/types/lib/services/AutoRenewService.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * 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 { ServiceInterface, ServiceManagerOptions } from '../core/types';
+import { TokenManagerInterface } from '../oidc/types';
+export declare class AutoRenewService implements ServiceInterface {
+    private tokenManager;
+    private options;
+    private renewTimeQueue;
+    private started;
+    constructor(tokenManager: TokenManagerInterface, options?: ServiceManagerOptions);
+    private shouldThrottleRenew;
+    requiresLeadership(): boolean;
+    private onTokenExpiredHandler;
+    canStart(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isStarted(): boolean;
+}

package/types/lib/services/LeaderElectionService.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 { ServiceInterface, ServiceManagerOptions } from '../core/types';
+declare type OnLeaderHandler = (() => Promise<void>);
+declare type ServiceOptions = ServiceManagerOptions & {
+    onLeader?: OnLeaderHandler;
+};
+export declare class LeaderElectionService implements ServiceInterface {
+    private options;
+    private channel?;
+    private elector?;
+    private started;
+    constructor(options?: ServiceOptions);
+    private onLeaderDuplicate;
+    private onLeader;
+    isLeader(): boolean;
+    hasLeader(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    requiresLeadership(): boolean;
+    isStarted(): boolean;
+    canStart(): boolean;
+}
+export {};

package/types/lib/services/SyncStorageService.d.ts

@@ -0,0 +1,38 @@
+/*!
+ * 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 { ServiceManagerOptions, ServiceInterface } from '../core/types';
+import { Token, Tokens, TokenManagerInterface } from '../oidc/types';
+export declare type SyncMessage = {
+    type: string;
+    key?: string;
+    token?: Token;
+    oldToken?: Token;
+    storage?: Tokens;
+};
+export declare class SyncStorageService implements ServiceInterface {
+    private tokenManager;
+    private options;
+    private channel?;
+    private started;
+    private enablePostMessage;
+    constructor(tokenManager: TokenManagerInterface, options?: ServiceManagerOptions);
+    requiresLeadership(): boolean;
+    isStarted(): boolean;
+    canStart(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private onTokenAddedHandler;
+    private onTokenRemovedHandler;
+    private onTokenRenewedHandler;
+    private onSetStorageHandler;
+    private onSyncMessageHandler;
+}

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

@@ -0,0 +1,3 @@
+import { SessionAPI } from './types';
+import { OktaAuthBaseInterface } from '../base/types';
+export declare function createSessionApi(sdk: OktaAuthBaseInterface): SessionAPI;

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

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

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

@@ -0,0 +1,5 @@
+import { OktaAuthHttpInterface, OktaAuthHttpOptions } from '../http/types';
+import { OktaAuthConstructor } from '../base/types';
+import { OktaAuthSessionInterface } from './types';
+import { StorageManagerInterface } from '../storage/types';
+export declare function mixinSession<S extends StorageManagerInterface = StorageManagerInterface, O extends OktaAuthHttpOptions = OktaAuthHttpOptions, TBase extends OktaAuthConstructor<OktaAuthHttpInterface<S, O>> = OktaAuthConstructor<OktaAuthHttpInterface<S, O>>>(Base: TBase): TBase & OktaAuthConstructor<OktaAuthSessionInterface<S, O>>;

package/types/lib/session/types.d.ts

@@ -0,0 +1,18 @@
+import { OktaAuthHttpInterface, OktaAuthHttpOptions } from '../http/types';
+import { StorageManagerInterface } from '../storage/types';
+export interface SessionObject {
+    status: string;
+    refresh?: () => Promise<object>;
+    user?: () => Promise<object>;
+}
+export interface SessionAPI {
+    close: () => Promise<object>;
+    exists: () => Promise<boolean>;
+    get: () => Promise<SessionObject>;
+    refresh: () => Promise<object>;
+    setCookieAndRedirect: (sessionToken?: string, redirectUri?: string) => void;
+}
+export interface OktaAuthSessionInterface<S extends StorageManagerInterface = StorageManagerInterface, O extends OktaAuthHttpOptions = OktaAuthHttpOptions> extends OktaAuthHttpInterface<S, O> {
+    session: SessionAPI;
+    closeSession(): Promise<unknown>;
+}

package/types/lib/storage/BaseStorageManager.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 { StorageUtil, StorageProvider, StorageOptions, CookieOptions, StorageManagerOptions, SimpleStorage, StorageManagerInterface } from './types';
+export declare function logServerSideMemoryStorageWarning(options: StorageOptions): void;
+export declare class BaseStorageManager implements StorageManagerInterface {
+    storageManagerOptions: StorageManagerOptions;
+    cookieOptions: CookieOptions;
+    storageUtil: StorageUtil;
+    constructor(storageManagerOptions: StorageManagerOptions, cookieOptions: CookieOptions, storageUtil: StorageUtil);
+    getOptionsForSection(sectionName: string, overrideOptions?: StorageOptions): StorageOptions;
+    getStorage(options: StorageOptions): SimpleStorage;
+    getTokenStorage(options?: StorageOptions): StorageProvider;
+    getHttpCache(options?: StorageOptions): StorageProvider;
+}

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

@@ -0,0 +1,25 @@
+/*!
+ * 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 { StorageProvider, SimpleStorage } from './types';
+export declare class SavedObject implements StorageProvider {
+    storageProvider: SimpleStorage;
+    storageName: string;
+    constructor(storage: SimpleStorage, storageName: string);
+    getItem(key: string): any;
+    setItem(key: string, value: any): void;
+    removeItem(key: string): void;
+    getStorage(): any;
+    setStorage(obj?: any): void;
+    clearStorage(key?: string): void;
+    updateStorage(key: any, value: any): void;
+}

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

@@ -0,0 +1,5 @@
+export * from './options/StorageOptionsConstructor';
+export * from './BaseStorageManager';
+export * from './mixin';
+export * from './SavedObject';
+export * from './types';

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

@@ -0,0 +1,3 @@
+import { OktaAuthBaseInterface, OktaAuthConstructor } from '../base/types';
+import { OktaAuthStorageInterface, OktaAuthStorageOptions, StorageManagerConstructor, StorageManagerInterface } from './types';
+export declare function mixinStorage<S extends StorageManagerInterface = StorageManagerInterface, O extends OktaAuthStorageOptions = OktaAuthStorageOptions, TBase extends OktaAuthConstructor<OktaAuthBaseInterface<O>> = OktaAuthConstructor<OktaAuthBaseInterface<O>>>(Base: TBase, StorageManager: StorageManagerConstructor<S>): TBase & OktaAuthConstructor<OktaAuthStorageInterface<S, O>>;

package/types/lib/storage/options/StorageOptionsConstructor.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * 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 { CookieOptions, StorageManagerOptions, StorageUtil } from '../types';
+export declare function createStorageOptionsConstructor(): {
+    new (args: any): {
+        cookies: CookieOptions;
+        storageUtil: StorageUtil;
+        storageManager: StorageManagerOptions;
+        devMode: boolean;
+    };
+};