@okta/okta-auth-js 6.4.1 → 6.5.0

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

@@ -9,6 +9,7 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
+import { Input } from './api';
 export interface ChallengeData {
     challenge: string;
     userVerification: string;
@@ -84,7 +85,7 @@ export interface IdxForm {
 export interface IdxOption {
     value: string | {
         form: IdxForm;
-    };
+    } | Input[];
     label: string;
     relatesTo?: IdxAuthenticator;
 }
@@ -123,7 +124,10 @@ export interface IdxRemediation {
     method?: string;
     type?: string;
     accepts?: string;
+    produces?: string;
     refresh?: number;
+    rel?: string[];
+    action?: (payload?: IdxActionParams) => Promise<IdxResponse>;
 }
 export interface IdxContext {
     version: string;
@@ -185,21 +189,28 @@ export interface RawIdxResponse {
 }
 export declare function isRawIdxResponse(obj: any): obj is RawIdxResponse;
 export interface IdxActionParams {
-    [key: string]: string | boolean | number;
+    [key: string]: string | boolean | number | object;
 }
 export interface IdxActions {
     [key: string]: (params?: IdxActionParams) => Promise<IdxResponse>;
 }
+export interface IdxToPersist {
+    interactionHandle?: string;
+    withCredentials?: boolean;
+}
+export interface IdxActionFunction {
+    (params: IdxActionParams): Promise<IdxResponse>;
+    neededParams?: Array<Array<IdxRemediationValue>>;
+}
 export interface IdxResponse {
     proceed: (remediationName: string, params: unknown) => Promise<IdxResponse>;
     neededToProceed: IdxRemediation[];
     rawIdxState: RawIdxResponse;
     interactionCode?: string;
     actions: IdxActions;
-    toPersist: {
-        interactionHandle?: string;
-    };
+    toPersist: IdxToPersist;
     context?: IdxContext;
     requestDidSucceed?: boolean;
+    stepUp?: boolean;
 }
 export declare function isIdxResponse(obj: any): obj is IdxResponse;

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

@@ -9,116 +9,10 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-import { InteractOptions } from '../interact';
-import { IntrospectOptions } from '../introspect';
-import { APIError, Tokens } from '../../types';
-import { PKCETransactionMeta } from '../../types/Transaction';
-import { IdxActions, IdxAuthenticator, IdxContext, IdxForm, IdxMessage, IdxOption, IdxRemediation, IdxResponse, RawIdxResponse } from './idx-js';
-import { FlowIdentifier } from './FlowIdentifier';
-export type { IdxMessage, IdxMessages, ChallengeData, ActivationData, IdxResponse, IdxContext, RawIdxResponse } from './idx-js';
-export type { AuthenticationOptions } from '../authenticate';
-export type { RegistrationOptions } from '../register';
-export type { PasswordRecoveryOptions } from '../recoverPassword';
-export type { AccountUnlockOptions } from '../unlockAccount';
-export type { ProceedOptions } from '../proceed';
-export type { CancelOptions } from '../cancel';
-export type { RemediateOptions } from '../remediate';
-export type { FlowIdentifier };
-export type { IdxAuthenticator };
+export * from './api';
+export * from './options';
+export type { IdxMessage, IdxMessages, ChallengeData, ActivationData, IdxResponse, IdxContext, RawIdxResponse, IdxRemediation, IdxAuthenticator, IdxActionParams, } from './idx-js';
+export type { FlowIdentifier } from './FlowIdentifier';
 export type { EmailVerifyCallbackResponse } from '../emailVerify';
 export type { WebauthnEnrollValues } from '../authenticator/WebauthnEnrollment';
 export type { WebauthnVerificationValues } from '../authenticator/WebauthnVerification';
-export declare enum IdxStatus {
-    SUCCESS = "SUCCESS",
-    PENDING = "PENDING",
-    FAILURE = "FAILURE",
-    TERMINAL = "TERMINAL",
-    CANCELED = "CANCELED"
-}
-export declare enum AuthenticatorKey {
-    OKTA_PASSWORD = "okta_password",
-    OKTA_EMAIL = "okta_email",
-    PHONE_NUMBER = "phone_number",
-    GOOGLE_AUTHENTICATOR = "google_otp",
-    SECURITY_QUESTION = "security_question",
-    OKTA_VERIFY = "okta_verify",
-    WEBAUTHN = "webauthn"
-}
-export declare type Input = {
-    name: string;
-    key?: string;
-    type?: string;
-    label?: string;
-    value?: string | {
-        form: IdxForm;
-    };
-    minLength?: number;
-    maxLength?: number;
-    secret?: boolean;
-    required?: boolean;
-};
-export interface IdxPollOptions {
-    required?: boolean;
-    refresh?: number;
-}
-export declare type NextStep = {
-    name: string;
-    authenticator?: IdxAuthenticator;
-    canSkip?: boolean;
-    canResend?: boolean;
-    inputs?: Input[];
-    options?: IdxOption[];
-    poll?: IdxPollOptions;
-    authenticatorEnrollments?: IdxAuthenticator[];
-};
-export declare enum IdxFeature {
-    PASSWORD_RECOVERY = "recover-password",
-    REGISTRATION = "enroll-profile",
-    SOCIAL_IDP = "redirect-idp",
-    ACCOUNT_UNLOCK = "unlock-account"
-}
-export interface IdxTransactionMeta extends PKCETransactionMeta {
-    interactionHandle?: string;
-    remediations?: string[];
-    flow?: FlowIdentifier;
-    withCredentials?: boolean;
-    activationToken?: string;
-    recoveryToken?: string;
-}
-export interface IdxTransaction {
-    status: IdxStatus;
-    tokens?: Tokens;
-    nextStep?: NextStep;
-    messages?: IdxMessage[];
-    error?: APIError | IdxResponse;
-    meta?: IdxTransactionMeta;
-    enabledFeatures?: IdxFeature[];
-    availableSteps?: NextStep[];
-    requestDidSucceed?: boolean;
-    proceed: (remediationName: string, params: unknown) => Promise<IdxResponse>;
-    neededToProceed: IdxRemediation[];
-    rawIdxState: RawIdxResponse;
-    interactionCode?: string;
-    actions: IdxActions;
-    context: IdxContext;
-}
-export declare type IdxOptions = InteractOptions & IntrospectOptions & {
-    flow?: FlowIdentifier;
-    exchangeCodeForTokens?: boolean;
-    autoRemediate?: boolean;
-    step?: string;
-};
-export declare type Authenticator = {
-    id?: string;
-    key?: string;
-    methodType?: string;
-    phoneNumber?: string;
-};
-export declare function isAuthenticator(obj: any): obj is Authenticator;
-export interface RemediationResponse {
-    idxResponse: IdxResponse;
-    nextStep?: NextStep;
-    messages?: IdxMessage[];
-    terminal?: boolean;
-    canceled?: boolean;
-}

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

@@ -0,0 +1,46 @@
+import { RemediationFlow } from '../flow';
+import { RemediateAction } from '../remediate';
+import { FlowIdentifier } from './FlowIdentifier';
+import { AuthenticatorVerificationDataValues, EnrollProfileValues, ResetAuthenticatorValues, SelectAuthenticatorUnlockAccountValues, SkipValues, EnrollPollValues as EnrollPollOptions, SelectEnrollmentChannelValues as SelectEnrollmentChannelOptions, IdentifyValues, SelectAuthenticatorAuthenticateValues, ChallengeAuthenticatorValues, ReEnrollAuthenticatorValues, AuthenticatorEnrollmentDataValues, SelectAuthenticatorEnrollValues, EnrollAuthenticatorValues } from '../remediators';
+export interface IdxOptions {
+    flow?: FlowIdentifier;
+    exchangeCodeForTokens?: boolean;
+    autoRemediate?: boolean;
+    step?: string;
+    withCredentials?: boolean;
+}
+export interface InteractOptions extends IdxOptions {
+    state?: string;
+    scopes?: string[];
+    codeChallenge?: string;
+    codeChallengeMethod?: string;
+    activationToken?: string;
+    recoveryToken?: string;
+    clientSecret?: string;
+    maxAge?: string | number;
+}
+export interface IntrospectOptions extends IdxOptions {
+    interactionHandle?: string;
+    stateHandle?: string;
+    version?: string;
+}
+export interface RemediateOptions extends IdxOptions {
+    remediators?: RemediationFlow;
+    actions?: RemediateAction[];
+    shouldProceedWithEmailAuthenticator?: boolean;
+    useGenericRemediator?: boolean;
+}
+export interface RunOptions extends RemediateOptions, InteractOptions, IntrospectOptions {
+}
+export interface AuthenticationOptions extends RunOptions, IdentifyValues, SelectAuthenticatorAuthenticateValues, SelectAuthenticatorEnrollValues, ChallengeAuthenticatorValues, ReEnrollAuthenticatorValues, AuthenticatorEnrollmentDataValues, EnrollAuthenticatorValues {
+}
+export interface RegistrationOptions extends RunOptions, IdentifyValues, EnrollProfileValues, SelectAuthenticatorEnrollValues, EnrollAuthenticatorValues, AuthenticatorEnrollmentDataValues, SkipValues {
+}
+export interface PasswordRecoveryOptions extends RunOptions, IdentifyValues, SelectAuthenticatorAuthenticateValues, ChallengeAuthenticatorValues, ResetAuthenticatorValues, AuthenticatorVerificationDataValues, ReEnrollAuthenticatorValues {
+}
+export interface AccountUnlockOptions extends RunOptions, IdentifyValues, SelectAuthenticatorUnlockAccountValues, SelectAuthenticatorAuthenticateValues, ChallengeAuthenticatorValues, AuthenticatorVerificationDataValues {
+}
+export interface ProceedOptions extends AuthenticationOptions, RegistrationOptions, PasswordRecoveryOptions, AccountUnlockOptions, EnrollPollOptions, SelectEnrollmentChannelOptions {
+}
+export declare type CancelOptions = IdxOptions;
+export declare type StartOptions = RunOptions;

package/lib/idx/unlockAccount.d.ts

@@ -9,7 +9,5 @@
  *
  * See the License for the specific language governing permissions and limitations under the License.
  */
-import { IdentifyValues, SelectAuthenticatorUnlockAccountValues, SelectAuthenticatorAuthenticateValues, ChallengeAuthenticatorValues, AuthenticatorVerificationDataValues } from './remediators';
-import { OktaAuthInterface, IdxOptions, IdxTransaction } from '../types';
-export declare type AccountUnlockOptions = IdxOptions & IdentifyValues & SelectAuthenticatorUnlockAccountValues & SelectAuthenticatorAuthenticateValues & ChallengeAuthenticatorValues & AuthenticatorVerificationDataValues;
+import { OktaAuthInterface, AccountUnlockOptions, IdxTransaction } from '../types';
 export declare function unlockAccount(authClient: OktaAuthInterface, options?: AccountUnlockOptions): Promise<IdxTransaction>;

package/lib/idx/util.d.ts

@@ -1,14 +1,15 @@
 import { RemediationValues, Remediator } from './remediators';
 import { IdxFeature, NextStep, RemediateOptions, RemediationResponse } from './types';
 import { IdxMessage, IdxRemediation, IdxRemediationValue, IdxResponse } from './types/idx-js';
+import { OktaAuthInterface } from '../types';
 export declare function isTerminalResponse(idxResponse: IdxResponse): boolean;
 export declare function canSkipFn(idxResponse: IdxResponse): boolean;
 export declare function canResendFn(idxResponse: IdxResponse): boolean;
 export declare function getMessagesFromIdxRemediationValue(value?: IdxRemediationValue[]): IdxMessage[] | undefined;
 export declare function getMessagesFromResponse(idxResponse: IdxResponse): IdxMessage[];
 export declare function getEnabledFeatures(idxResponse: IdxResponse): IdxFeature[];
-export declare function getAvailableSteps(idxResponse: IdxResponse): NextStep[];
+export declare function getAvailableSteps(authClient: OktaAuthInterface, idxResponse: IdxResponse, useGenericRemediator?: boolean): NextStep[];
 export declare function filterValuesForRemediation(idxResponse: IdxResponse, remediationName: string, values: RemediationValues): RemediationValues;
 export declare function getRemediator(idxRemediations: IdxRemediation[], values: RemediationValues, options: RemediateOptions): Remediator | undefined;
-export declare function getNextStep(remediator: Remediator, idxResponse: IdxResponse): NextStep;
-export declare function handleIdxError(e: any, remediator?: any): RemediationResponse;
+export declare function getNextStep(authClient: OktaAuthInterface, remediator: Remediator, idxResponse: IdxResponse): NextStep;
+export declare function handleIdxError(authClient: OktaAuthInterface, e: any, remediator?: any): RemediationResponse;

package/lib/types/OAuth.d.ts

@@ -56,3 +56,5 @@ export interface WellKnownResponse {
     scopes_supported: string[];
     claims_supported: string[];
 }
+export declare type OAuthResponseMode = 'okta_post_message' | 'fragment' | 'query' | 'form_post';
+export declare type OAuthResponseType = 'code' | 'token' | 'id_token' | 'refresh_token';

package/lib/types/OktaAuthOptions.d.ts

@@ -14,9 +14,10 @@ import { CookieOptions } from './Cookies';
 import { HttpRequestClient } from './http';
 import { AuthState } from './AuthState';
 import { TransactionManagerOptions } from './Transaction';
-import { FlowIdentifier } from '../idx/types';
+import { IdxTransactionMeta } from '../idx/types';
 import { ServiceManagerOptions } from './Service';
 import OktaAuth from '../OktaAuth';
+import { OAuthResponseMode, OAuthResponseType } from './OAuth';
 export interface IsAuthenticatedOptions {
     onExpiredToken?: 'renew' | 'remove' | 'none';
 }
@@ -39,16 +40,36 @@ export interface CustomUrls {
     revokeUrl?: string;
     logoutUrl?: string;
 }
-export interface OktaAuthOptions extends CustomUrls {
+export interface TokenParams extends CustomUrls {
     pkce?: boolean;
     clientId?: string;
     redirectUri?: string;
-    useInteractionCodeFlow?: boolean;
-    responseType?: string | string[];
-    responseMode?: string;
-    scopes?: 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 OktaAuthOptions extends CustomUrls, Pick<TokenParams, 'issuer' | 'clientId' | 'redirectUri' | 'responseType' | 'responseMode' | 'scopes' | 'state' | 'pkce' | 'ignoreSignature' | 'codeChallenge' | 'codeChallengeMethod'>, Pick<IdxTransactionMeta, 'flow' | 'activationToken' | 'recoveryToken'> {
+    useInteractionCodeFlow?: boolean;
     ignoreLifetime?: boolean;
     tokenManager?: TokenManagerOptions;
     postLogoutRedirectUri?: string;
@@ -65,10 +86,6 @@ export interface OktaAuthOptions extends CustomUrls {
     storageManager?: StorageManagerOptions;
     services?: ServiceManagerOptions;
     transactionManager?: TransactionManagerOptions;
-    flow?: FlowIdentifier;
-    codeChallenge?: string;
-    codeChallengeMethod?: string;
-    recoveryToken?: string;
-    activationToken?: string;
+    idx?: Pick<IdxTransactionMeta, 'useGenericRemediator'>;
     clientSecret?: string;
 }

package/lib/types/Storage.d.ts

@@ -12,6 +12,7 @@
 import { TransactionMeta } from './Transaction';
 import { Cookies, CookieOptions } from './Cookies';
 import { RawIdxResponse } from '../idx/types/idx-js';
+import { IntrospectOptions } from '.';
 export interface TxStorage {
     get(name: string): string;
     set(name: string, value: string, expiresAt: string, options: CookieOptions): string;
@@ -40,7 +41,7 @@ export interface TransactionStorage extends StorageProvider {
     setStorage(obj: TransactionMeta): void;
     getStorage(): TransactionMeta;
 }
-export interface SavedIdxResponse {
+export interface SavedIdxResponse extends Pick<IntrospectOptions, 'stateHandle' | 'interactionHandle'> {
     rawIdxResponse: RawIdxResponse;
     requestDidSucceed?: boolean;
 }

package/lib/types/Transaction.d.ts

@@ -10,8 +10,8 @@
  * See the License for the specific language governing permissions and limitations under the License.
  */
 import { StorageManager } from '../StorageManager';
-import { CustomUrls } from './OktaAuthOptions';
-import { FlowIdentifier, IdxTransactionMeta } from '../idx/types';
+import { CustomUrls, TokenParams } from './OktaAuthOptions';
+import { IdxTransactionMeta } from '../idx/types';
 export interface TransactionManagerOptions {
     storageManager?: StorageManager;
     enableSharedStorage?: boolean;
@@ -21,38 +21,18 @@ export interface TransactionManagerOptions {
     saveParamsCookie?: boolean;
     saveLastResponse?: boolean;
 }
-export interface TransactionMetaOptions {
-    pkce?: boolean;
-    oauth?: boolean;
-    muteWarning?: boolean;
-    state?: string;
-    flow?: FlowIdentifier;
-    codeVerifier?: string;
-    codeChallenge?: string;
-    codeChallengeMethod?: string;
-    activationToken?: string;
-    recoveryToken?: string;
-}
-export interface OAuthTransactionMeta {
-    issuer: string;
-    redirectUri: string;
-    state: string;
-    nonce: string;
-    responseType: string | string[];
-    responseMode?: string;
-    scopes: string[];
-    clientId: string;
+export interface OAuthTransactionMeta extends Pick<TokenParams, 'issuer' | 'clientId' | 'redirectUri' | 'responseType' | 'responseMode' | 'scopes' | 'state' | 'pkce' | 'ignoreSignature' | 'nonce'> {
     urls: CustomUrls;
-    ignoreSignature: boolean;
     originalUri?: string;
 }
-export interface PKCETransactionMeta extends OAuthTransactionMeta {
-    codeVerifier: string;
-    codeChallengeMethod: string;
-    codeChallenge: string;
+export interface PKCETransactionMeta extends OAuthTransactionMeta, Pick<TokenParams, 'codeChallenge' | 'codeChallengeMethod' | 'codeVerifier'> {
 }
 export declare type CustomAuthTransactionMeta = Record<string, string | undefined>;
 export declare type TransactionMeta = IdxTransactionMeta | PKCETransactionMeta | OAuthTransactionMeta | CustomAuthTransactionMeta;
+export interface TransactionMetaOptions extends Pick<IdxTransactionMeta, 'pkce' | 'state' | 'codeChallenge' | 'codeChallengeMethod' | 'codeVerifier' | 'flow' | 'activationToken' | 'recoveryToken'> {
+    oauth?: boolean;
+    muteWarning?: boolean;
+}
 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;

package/lib/types/api.d.ts

@@ -13,16 +13,13 @@ import { AuthTransaction } from '../tx/AuthTransaction';
 import { Token, Tokens, RevocableToken, AccessToken, IDToken, RefreshToken } from './Token';
 import { JWTObject } from './JWT';
 import { UserClaims } from './UserClaims';
-import { CustomUrls, OktaAuthOptions } from './OktaAuthOptions';
+import { CustomUrls, OktaAuthOptions, TokenParams } from './OktaAuthOptions';
 import { StorageManager } from '../StorageManager';
 import TransactionManager from '../TransactionManager';
 import { TokenManagerInterface } from './TokenManager';
 import { ServiceManagerInterface } from './Service';
 import { OktaUserAgent } from '../OktaUserAgent';
-import { AuthenticationOptions, RegistrationOptions as IdxRegistrationOptions, PasswordRecoveryOptions, AccountUnlockOptions, ProceedOptions, CancelOptions, IdxOptions, IdxTransaction, IdxTransactionMeta, EmailVerifyCallbackResponse, IdxAuthenticator, ChallengeData, ActivationData, WebauthnEnrollValues, WebauthnVerificationValues, FlowIdentifier, IdxPollOptions } from '../idx/types';
-import { InteractOptions, InteractResponse } from '../idx/interact';
-import { IntrospectOptions } from '../idx/introspect';
-import { IdxResponse } from '../idx/types/idx-js';
+import { AuthenticationOptions, RegistrationOptions as IdxRegistrationOptions, PasswordRecoveryOptions, AccountUnlockOptions, ProceedOptions, CancelOptions, IdxTransaction, IdxTransactionMeta, EmailVerifyCallbackResponse, IdxAuthenticator, ChallengeData, ActivationData, WebauthnEnrollValues, WebauthnVerificationValues, FlowIdentifier, IdxPollOptions, IdxResponse, IntrospectOptions, InteractOptions, InteractResponse, StartOptions } from '../idx/types';
 import { TransactionMetaOptions } from './Transaction';
 export interface OktaAuthInterface {
     options: OktaAuthOptions;
@@ -37,12 +34,19 @@ export interface OktaAuthInterface {
     features: FeaturesAPI;
     token: TokenAPI;
 }
+export interface FieldError {
+    errorSummary: string;
+    reason?: string;
+    location?: string;
+    locationType?: string;
+    domain?: string;
+}
 export interface APIError {
     errorSummary: string;
     errorCode?: string;
     errorLink?: string;
     errorId?: string;
-    errorCauses?: string[];
+    errorCauses?: Array<FieldError>;
 }
 export interface HttpAPI {
     setRequestHeader(name: string, value: string): void;
@@ -73,34 +77,6 @@ export interface SessionAPI {
     refresh: () => Promise<object>;
     setCookieAndRedirect: (sessionToken?: string, redirectUri?: string) => void;
 }
-export interface TokenParams extends CustomUrls {
-    pkce?: boolean;
-    clientId?: string;
-    redirectUri?: string;
-    responseType?: string | string[];
-    responseMode?: string;
-    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 PopupParams {
     popupTitle?: string;
     popupWindow?: Window;
@@ -231,13 +207,13 @@ export interface IdxAPI {
     recoverPassword: (options?: PasswordRecoveryOptions) => Promise<IdxTransaction>;
     unlockAccount: (options?: AccountUnlockOptions) => Promise<IdxTransaction>;
     poll: (options?: IdxPollOptions) => Promise<IdxTransaction>;
-    start: (options?: IdxOptions) => Promise<IdxTransaction>;
+    start: (options?: StartOptions) => Promise<IdxTransaction>;
     canProceed(options?: ProceedOptions): boolean;
     proceed: (options?: ProceedOptions) => Promise<IdxTransaction>;
     cancel: (options?: CancelOptions) => Promise<IdxTransaction>;
     getFlow(): FlowIdentifier | undefined;
     setFlow(flow: FlowIdentifier): void;
-    startTransaction: (options?: IdxOptions) => Promise<IdxTransaction>;
+    startTransaction: (options?: StartOptions) => Promise<IdxTransaction>;
     isInteractionRequired: (hashOrSearch?: string) => boolean;
     isInteractionRequiredError: (error: Error) => boolean;
     handleInteractionCodeRedirect: (url: string) => Promise<void>;

package/package.json

@@ -2,7 +2,7 @@
   "private": false,
   "name": "@okta/okta-auth-js",
   "description": "The Okta Auth SDK",
-  "version": "6.4.1",
+  "version": "6.5.0",
   "homepage": "https://github.com/okta/okta-auth-js",
   "license": "Apache-2.0",
   "main": "cjs/index.js",
@@ -61,7 +61,8 @@
     "dev:samples": "yarn workspace @okta/samples dev",
     "prepare": "",
     "start": "yarn workspace @okta/test.app start --open",
-    "stop": "kill -s TERM $(lsof -t -i:8080 -sTCP:LISTEN) || true"
+    "stop": "kill -s TERM $(lsof -t -i:8080 -sTCP:LISTEN) || true",
+    "verify:package": "node scripts/verify-package.js"
   },
   "author": "Okta",
   "keywords": [
@@ -187,8 +188,8 @@
     }
   },
   "okta": {
-    "commitSha": "38f27304c795b6eb5e434915df7484e95e50094a",
-    "fullVersion": "6.4.1-g38f2730",
-    "testedSha": "d13b08bbe4f80b2009f48f2d1b1fcb4d64fc2450"
+    "commitSha": "73bc0e00190f7525f32c7e64eb757d18ef9f4ee1",
+    "fullVersion": "6.5.0-g73bc0e0",
+    "testedSha": "14720370492104c146b3b02dcee6bbdf463f9435"
   }
 }