@okta/okta-auth-js 6.9.0 → 7.0.0

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

@@ -0,0 +1,58 @@
+import { OAuthStorageManagerInterface, OAuthTransactionMeta, OktaAuthOAuthInterface, OktaAuthOAuthOptions, PKCETransactionMeta } from '../oidc/types';
+export { EmailTransaction, EmailStatusTransaction, EmailChallengeTransaction, PhoneTransaction, ProfileTransaction, ProfileSchemaTransaction, BaseTransaction } from './transactions';
+export declare enum EmailRole {
+    PRIMARY = "PRIMARY",
+    SECONDARY = "SECONDARY"
+}
+export declare enum Status {
+    VERIFIED = "VERIFIED",
+    UNVERIFIED = "UNVERIFIED"
+}
+export declare type EmailProfile = {
+    email: string;
+};
+export declare type AddEmailPayload = {
+    profile: {
+        email: string;
+    };
+    sendEmail: boolean;
+    role: EmailRole;
+};
+export declare type PhoneProfile = {
+    profile: {
+        phoneNumber: string;
+    };
+};
+export declare type AddPhonePayload = {
+    profile: {
+        phoneNumber: string;
+    };
+    sendCode: boolean;
+    method: string;
+};
+export declare type ChallengePhonePayload = {
+    method: string;
+};
+export declare type VerificationPayload = {
+    verificationCode: string;
+};
+export declare type UpdateProfilePayload = {
+    profile: {
+        firstName?: string;
+        lastName?: string;
+        email?: string;
+        login?: string;
+        [property: string]: any;
+    };
+};
+export declare type MyAccountRequestOptions = {
+    id?: string;
+    emailId?: string;
+    challengeId?: string;
+    payload?: AddEmailPayload | AddPhonePayload | ChallengePhonePayload | VerificationPayload | UpdateProfilePayload;
+    accessToken?: string;
+};
+export declare type IAPIFunction<T> = (oktaAuth: OktaAuthOAuthInterface, options?: MyAccountRequestOptions) => Promise<T>;
+export interface OktaAuthMyAccountInterface<M extends OAuthTransactionMeta = PKCETransactionMeta, S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>, O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions> extends OktaAuthOAuthInterface<M, S, O> {
+    myaccount: any;
+}

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

@@ -0,0 +1,53 @@
+import { Token, Tokens, TokenType, TokenManagerOptions, TokenManagerErrorEventHandler, TokenManagerSetStorageEventHandler, TokenManagerRenewEventHandler, TokenManagerEventHandler, TokenManagerInterface, RefreshToken, AccessTokenCallback, IDTokenCallback, RefreshTokenCallback, EVENT_RENEWED, EVENT_ADDED, EVENT_ERROR, EVENT_EXPIRED, EVENT_REMOVED, EVENT_SET_STORAGE, OktaAuthOAuthInterface } from './types';
+import { StorageProvider } from '../storage/types';
+export declare class TokenManager implements TokenManagerInterface {
+    private sdk;
+    private clock;
+    private emitter;
+    private storage;
+    private state;
+    private options;
+    on(event: typeof EVENT_RENEWED, handler: TokenManagerRenewEventHandler, context?: object): void;
+    on(event: typeof EVENT_ERROR, handler: TokenManagerErrorEventHandler, context?: object): void;
+    on(event: typeof EVENT_SET_STORAGE, handler: TokenManagerSetStorageEventHandler, context?: object): void;
+    on(event: typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED, handler: TokenManagerEventHandler, context?: object): void;
+    off(event: typeof EVENT_RENEWED, handler?: TokenManagerRenewEventHandler): void;
+    off(event: typeof EVENT_ERROR, handler?: TokenManagerErrorEventHandler): void;
+    off(event: typeof EVENT_SET_STORAGE, handler?: TokenManagerSetStorageEventHandler): void;
+    off(event: typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED, handler?: TokenManagerEventHandler): void;
+    constructor(sdk: OktaAuthOAuthInterface, options?: TokenManagerOptions);
+    start(): void;
+    stop(): void;
+    getOptions(): TokenManagerOptions;
+    getExpireTime(token: any): number;
+    hasExpired(token: any): boolean;
+    emitExpired(key: any, token: any): void;
+    emitRenewed(key: any, freshToken: any, oldToken: any): void;
+    emitAdded(key: any, token: any): void;
+    emitRemoved(key: any, token?: any): void;
+    emitError(error: any): void;
+    clearExpireEventTimeout(key: any): void;
+    clearExpireEventTimeoutAll(): void;
+    setExpireEventTimeout(key: any, token: any): void;
+    setExpireEventTimeoutAll(): void;
+    resetExpireEventTimeoutAll(): void;
+    add(key: any, token: Token): void;
+    getSync(key: any): Token;
+    get(key: any): Promise<Token>;
+    getTokensSync(): Tokens;
+    getTokens(): Promise<Tokens>;
+    getStorageKeyByType(type: TokenType): string;
+    private getTokenType;
+    private emitSetStorageEvent;
+    getStorage(): StorageProvider;
+    setTokens(tokens: Tokens, accessTokenCb?: AccessTokenCallback, idTokenCb?: IDTokenCallback, refreshTokenCb?: RefreshTokenCallback): void;
+    remove(key: any): void;
+    renewToken(token: any): Promise<Token | undefined>;
+    validateToken(token: Token): void;
+    renew(key: any): Promise<Token | undefined>;
+    clear(): void;
+    clearPendingRemoveTokens(): void;
+    updateRefreshToken(token: RefreshToken): void;
+    removeRefreshToken(): void;
+    addPendingRemoveFlags(): void;
+}

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

@@ -0,0 +1,24 @@
+/*!
+ * 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 { TransactionMeta, TransactionMetaOptions, TransactionManagerOptions, OAuthTransactionMeta, OAuthStorageManagerInterface, ClearTransactionMetaOptions, PKCETransactionMeta } from './types';
+export declare function createTransactionManager<M extends OAuthTransactionMeta = PKCETransactionMeta, S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>>(): {
+    new (options: TransactionManagerOptions): {
+        options: TransactionManagerOptions;
+        storageManager: S;
+        enableSharedStorage: boolean;
+        saveLastResponse: boolean;
+        clear(options?: ClearTransactionMetaOptions): void;
+        save(meta: M, options?: TransactionMetaOptions): void;
+        exists(options?: TransactionMetaOptions): boolean;
+        load(options?: TransactionMetaOptions): TransactionMeta | null;
+    };
+};

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

@@ -0,0 +1,2 @@
+import { JWTObject } from './types';
+export declare function decodeToken(token: string): JWTObject;

package/types/lib/oidc/endpoints/authorize.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 { OAuthParams, TokenParams } from '../types';
+export declare function convertTokenParamsToOAuthParams(tokenParams: TokenParams): OAuthParams;
+export declare function buildAuthorizeParams(tokenParams: TokenParams): string;

package/types/lib/oidc/endpoints/token.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 { CustomUrls, OAuthResponse, RefreshToken, TokenParams } from '../types';
+import { OktaAuthHttpInterface } from '../../http';
+export declare function postToTokenEndpoint(sdk: any, options: TokenParams, urls: CustomUrls): Promise<OAuthResponse>;
+export declare function postRefreshToken(sdk: OktaAuthHttpInterface, options: TokenParams, refreshToken: RefreshToken): Promise<OAuthResponse>;

package/types/lib/oidc/endpoints/well-known.d.ts

@@ -0,0 +1,3 @@
+import { OktaAuthOAuthInterface, WellKnownResponse } from '../types';
+export declare function getWellKnown(sdk: OktaAuthOAuthInterface, issuer?: string): Promise<WellKnownResponse>;
+export declare function getKey(sdk: OktaAuthOAuthInterface, issuer: string, kid: string): Promise<string>;

package/types/lib/oidc/exchangeCodeForTokens.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 { CustomUrls, OktaAuthOAuthInterface, TokenParams, TokenResponse } from './types';
+export declare function exchangeCodeForTokens(sdk: OktaAuthOAuthInterface, tokenParams: TokenParams, urls?: CustomUrls): Promise<TokenResponse>;

package/types/lib/oidc/factory/OktaAuthOAuth.d.ts

@@ -0,0 +1,4 @@
+import { StorageManagerConstructor } from '../../storage/types';
+import { OktaAuthConstructor, OktaAuthOptionsConstructor } from '../../base/types';
+import { OAuthTransactionMeta, OktaAuthOAuthInterface, OktaAuthOAuthOptions, OAuthStorageManagerInterface, PKCETransactionMeta, TransactionManagerConstructor, TransactionManagerInterface } from '../types';
+export declare function createOktaAuthOAuth<M extends OAuthTransactionMeta = PKCETransactionMeta, S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>, O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions, TM extends TransactionManagerInterface = TransactionManagerInterface>(StorageManagerConstructor: StorageManagerConstructor<S>, OptionsConstructor: OktaAuthOptionsConstructor<O>, TransactionManagerConstructor: TransactionManagerConstructor<TM>): OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O, TM>>;

package/types/lib/oidc/factory/api.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 { PromiseQueue } from '../../util';
+import { OktaAuthOAuthInterface, TokenAPI } from '../types';
+export declare function createTokenAPI(sdk: OktaAuthOAuthInterface, queue: PromiseQueue): TokenAPI;

package/types/lib/oidc/factory/index.d.ts

@@ -0,0 +1,2 @@
+export * from './api';
+export * from './OktaAuthOAuth';

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

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

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

@@ -0,0 +1,2 @@
+import { AccessToken, IDToken, UserClaims, CustomUserClaims } from './types';
+export declare function getUserInfo<T extends CustomUserClaims = CustomUserClaims>(sdk: any, accessTokenObject: AccessToken, idTokenObject: IDToken): Promise<UserClaims<T>>;

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

@@ -0,0 +1,2 @@
+import { OktaAuthOAuthInterface, TokenParams, TokenResponse } from './types';
+export declare function getWithPopup(sdk: OktaAuthOAuthInterface, options: TokenParams): Promise<TokenResponse>;

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

@@ -0,0 +1,2 @@
+import { OktaAuthOAuthInterface, TokenParams } from './types';
+export declare function getWithRedirect(sdk: OktaAuthOAuthInterface, options?: TokenParams): Promise<void>;

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

@@ -0,0 +1,2 @@
+import { OktaAuthOAuthInterface, TokenParams, TokenResponse } from './types';
+export declare function getWithoutPrompt(sdk: OktaAuthOAuthInterface, options: TokenParams): Promise<TokenResponse>;

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

@@ -0,0 +1,2 @@
+import { OktaAuthOAuthInterface, OAuthResponse, TokenParams, TokenResponse, CustomUrls } from './types';
+export declare function handleOAuthResponse(sdk: OktaAuthOAuthInterface, tokenParams: TokenParams, res: OAuthResponse, urls?: CustomUrls): Promise<TokenResponse>;

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

@@ -0,0 +1,35 @@
+/*!
+ * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.
+ * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the "License.")
+ *
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and limitations under the License.
+ *
+ */
+export * from './factory';
+export * from './mixin';
+export * from './storage';
+export * from './endpoints';
+export * from './options';
+export * from './types';
+export * from './TokenManager';
+export * from './TransactionManager';
+export * from './util';
+export { decodeToken } from './decodeToken';
+export { revokeToken } from './revokeToken';
+export { renewToken } from './renewToken';
+export { renewTokensWithRefresh } from './renewTokensWithRefresh';
+export { renewTokens } from './renewTokens';
+export { verifyToken } from './verifyToken';
+export { getUserInfo } from './getUserInfo';
+export { handleOAuthResponse } from './handleOAuthResponse';
+export { exchangeCodeForTokens } from './exchangeCodeForTokens';
+export { getToken } from './getToken';
+export { getWithoutPrompt } from './getWithoutPrompt';
+export { getWithPopup } from './getWithPopup';
+export { getWithRedirect } from './getWithRedirect';
+export { parseFromUrl } from './parseFromUrl';

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

@@ -0,0 +1,17 @@
+import { OktaAuthStorageInterface } from '../../storage';
+import { OktaAuthConstructor } from '../../base';
+import { OAuthStorageManagerInterface, OAuthTransactionMeta, OktaAuthOAuthOptions, PKCETransactionMeta } from '../types';
+export declare function provideOriginalUri<M extends OAuthTransactionMeta = PKCETransactionMeta, S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>, O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions, TBase extends OktaAuthConstructor<OktaAuthStorageInterface<S, O>> = OktaAuthConstructor<OktaAuthStorageInterface<S, O>>>(BaseClass: TBase): {
+    new (...args: any[]): {
+        setOriginalUri(originalUri: string, state?: string): void;
+        getOriginalUri(state?: string): string | undefined;
+        removeOriginalUri(state?: string): void;
+        storageManager: S;
+        clearStorage(): void;
+        options: O;
+        emitter: import("../../base").EventEmitter;
+        features: import("../../base").FeaturesAPI;
+    };
+    features: import("../../base").FeaturesAPI;
+    constants: typeof import("../../constants");
+} & TBase;

package/types/lib/oidc/mixin/index.d.ts

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

package/types/lib/oidc/mixin/node.d.ts

@@ -0,0 +1,17 @@
+import { OktaAuthStorageInterface } from '../../storage';
+import { OktaAuthConstructor } from '../../base';
+import { OAuthStorageManagerInterface, OAuthTransactionMeta, OktaAuthOAuthOptions, PKCETransactionMeta } from '../types';
+export declare function provideOriginalUri<M extends OAuthTransactionMeta = PKCETransactionMeta, S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>, O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions, TBase extends OktaAuthConstructor<OktaAuthStorageInterface<S, O>> = OktaAuthConstructor<OktaAuthStorageInterface<S, O>>>(BaseClass: TBase): {
+    new (...args: any[]): {
+        setOriginalUri(originalUri: string, state?: string): void;
+        getOriginalUri(state?: string): string | undefined;
+        removeOriginalUri(state?: string): void;
+        storageManager: S;
+        clearStorage(): void;
+        options: O;
+        emitter: import("../../base").EventEmitter;
+        features: import("../../base").FeaturesAPI;
+    };
+    features: import("../../base").FeaturesAPI;
+    constants: typeof import("../../constants");
+} & TBase;

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

@@ -0,0 +1,48 @@
+/*!
+ * 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 { OAuthResponseMode, OAuthResponseType, OktaAuthOAuthInterface, SetLocationFunction, TokenManagerOptions, TransactionManagerOptions } from '../types';
+export declare function createOAuthOptionsConstructor(): {
+    new (options: any): {
+        issuer: string;
+        authorizeUrl: string;
+        userinfoUrl: string;
+        tokenUrl: string;
+        revokeUrl: string;
+        logoutUrl: string;
+        pkce: boolean;
+        clientId: string;
+        redirectUri: string;
+        responseType: OAuthResponseType | OAuthResponseType[];
+        responseMode: OAuthResponseMode;
+        state: string;
+        scopes: string[];
+        ignoreSignature: boolean;
+        codeChallenge: string;
+        codeChallengeMethod: string;
+        tokenManager: TokenManagerOptions;
+        postLogoutRedirectUri: string;
+        restoreOriginalUri: (oktaAuth: OktaAuthOAuthInterface, originalUri?: string) => Promise<void>;
+        transactionManager: TransactionManagerOptions;
+        clientSecret: string;
+        setLocation: 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/oidc/options/browser.d.ts

@@ -0,0 +1 @@
+export declare const enableSharedStorage = true;

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

@@ -0,0 +1 @@
+export * from './OAuthOptionsConstructor';

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

@@ -0,0 +1 @@
+export declare const enableSharedStorage = false;

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

@@ -0,0 +1,5 @@
+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/types/lib/oidc/renewToken.d.ts

@@ -0,0 +1,2 @@
+import { OktaAuthOAuthInterface, Token } from './types';
+export declare function renewToken(sdk: OktaAuthOAuthInterface, token: Token): Promise<Token | undefined>;

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

@@ -0,0 +1,2 @@
+import { TokenParams, Tokens } from './types';
+export declare function renewTokens(sdk: any, options?: TokenParams): Promise<Tokens>;

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

@@ -0,0 +1,2 @@
+import { OktaAuthOAuthInterface, TokenParams, RefreshToken, Tokens } from './types';
+export declare function renewTokensWithRefresh(sdk: OktaAuthOAuthInterface, tokenParams: TokenParams, refreshTokenObject: RefreshToken): Promise<Tokens>;

package/types/lib/oidc/revokeToken.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, RevocableToken } from './types';
+export declare function revokeToken(sdk: OktaAuthOAuthInterface, token: RevocableToken): Promise<any>;

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

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

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

@@ -0,0 +1,61 @@
+import { StorageProvider } from '../../storage/types';
+import { TokenManagerOptions } from './options';
+import { AccessToken, IDToken, RefreshToken, Token, Tokens, TokenType } from './Token';
+export interface TokenManagerError {
+    errorSummary: string;
+    errorCode: string;
+    message: string;
+    name: string;
+    tokenKey: string;
+}
+export declare type AccessTokenCallback = (key: string, token: AccessToken) => void;
+export declare type IDTokenCallback = (key: string, token: IDToken) => void;
+export declare type RefreshTokenCallback = (key: string, token: RefreshToken) => void;
+export declare const EVENT_EXPIRED = "expired";
+export declare const EVENT_RENEWED = "renewed";
+export declare const EVENT_ADDED = "added";
+export declare const EVENT_REMOVED = "removed";
+export declare const EVENT_ERROR = "error";
+export declare const EVENT_SET_STORAGE = "set_storage";
+export declare type TokenManagerErrorEventHandler = (error: TokenManagerError) => void;
+export declare type TokenManagerEventHandler = (key: string, token: Token) => void;
+export declare type TokenManagerRenewEventHandler = (key: string, token: Token, oldtoken: Token) => void;
+export declare type TokenManagerSetStorageEventHandler = (storage: Tokens) => void;
+export declare type TokenManagerAnyEventHandler = TokenManagerErrorEventHandler | TokenManagerRenewEventHandler | TokenManagerSetStorageEventHandler | TokenManagerEventHandler;
+export declare type TokenManagerAnyEvent = typeof EVENT_RENEWED | typeof EVENT_ERROR | typeof EVENT_SET_STORAGE | typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED;
+export interface TokenManagerInterface {
+    on(event: typeof EVENT_RENEWED, handler: TokenManagerRenewEventHandler, context?: object): void;
+    on(event: typeof EVENT_ERROR, handler: TokenManagerErrorEventHandler, context?: object): void;
+    on(event: typeof EVENT_SET_STORAGE, handler: TokenManagerSetStorageEventHandler, context?: object): void;
+    on(event: typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED, handler: TokenManagerEventHandler, context?: object): void;
+    off(event: typeof EVENT_RENEWED, handler?: TokenManagerRenewEventHandler): void;
+    off(event: typeof EVENT_ERROR, handler?: TokenManagerErrorEventHandler): void;
+    off(event: typeof EVENT_SET_STORAGE, handler?: TokenManagerSetStorageEventHandler): void;
+    off(event: typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED, handler?: TokenManagerEventHandler): void;
+    clear(): void;
+    setExpireEventTimeout(key: string, token: Token): void;
+    clearExpireEventTimeout(key: string): void;
+    clearExpireEventTimeoutAll(): void;
+    emitAdded(key: string, token: Token): void;
+    emitError(error: Error): void;
+    emitRemoved(key: string, token: Token): void;
+    emitRenewed(key: string, token: Token, oldToken?: Token): void;
+    renew(key: string): Promise<Token | undefined>;
+    remove(key: string): void;
+    hasExpired(token: Token): boolean;
+    getExpireTime(token: Token): number;
+    get(key: any): Promise<Token>;
+    getSync(key: any): Token;
+    getTokens(): Promise<Tokens>;
+    getTokensSync(): Tokens;
+    setTokens({ accessToken, idToken, refreshToken }: Tokens, accessTokenCb?: AccessTokenCallback, idTokenCb?: IDTokenCallback, refreshTokenCb?: RefreshTokenCallback): void;
+    getStorageKeyByType(type: TokenType): string;
+    add(key: any, token: Token): void;
+    updateRefreshToken(token: RefreshToken): any;
+    removeRefreshToken(): void;
+    clearPendingRemoveTokens(): void;
+    getOptions(): TokenManagerOptions;
+    getStorage(): StorageProvider;
+    start(): any;
+    stop(): any;
+}

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

@@ -0,0 +1,29 @@
+/*!
+ * 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 { IdxTransactionMeta } from '../../idx/types/meta';
+import { OAuthTransactionMeta, PKCETransactionMeta } from './meta';
+import { OAuthStorageManagerInterface } from './storage';
+export interface TransactionManagerOptions {
+    storageManager?: OAuthStorageManagerInterface;
+    enableSharedStorage?: boolean;
+    saveNonceCookie?: boolean;
+    saveStateCookie?: boolean;
+    saveParamsCookie?: boolean;
+    saveLastResponse?: boolean;
+}
+export declare type CustomAuthTransactionMeta = Record<string, string | undefined>;
+export declare type TransactionMeta = IdxTransactionMeta | PKCETransactionMeta | OAuthTransactionMeta | CustomAuthTransactionMeta;
+export declare function isOAuthTransactionMeta(obj: any): obj is OAuthTransactionMeta;
+export declare function isPKCETransactionMeta(obj: any): obj is PKCETransactionMeta;
+export declare function isIdxTransactionMeta(obj: any): obj is IdxTransactionMeta;
+export declare function isCustomAuthTransactionMeta(obj: any): obj is CustomAuthTransactionMeta;
+export declare function isTransactionMeta(obj: any): obj is TransactionMeta;

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

@@ -0,0 +1,15 @@
+import { OAuthTransactionMeta, TransactionMetaOptions } from './meta';
+import { TransactionManagerOptions, TransactionMeta } from './Transaction';
+export interface ClearTransactionMetaOptions extends TransactionMetaOptions {
+    clearSharedStorage?: boolean;
+    clearIdxResponse?: boolean;
+}
+export interface TransactionManagerInterface {
+    clear(options?: ClearTransactionMetaOptions): any;
+    save(meta: OAuthTransactionMeta, options?: TransactionMetaOptions): any;
+    exists(options?: TransactionMetaOptions): any;
+    load(options?: TransactionMetaOptions): TransactionMeta | null;
+}
+export interface TransactionManagerConstructor<TM extends TransactionManagerInterface = TransactionManagerInterface> {
+    new (options: TransactionManagerOptions): TM;
+}