@tern-secure/auth 1.1.0-canary.v20251108045933 → 1.1.0-canary.v20251125170702

package/dist/types/auth/AuthCookieManager.d.ts

@@ -39,4 +39,3 @@ export declare class AuthCookieManager {
     clearAuth(): void;
 }
 export {};
-//# sourceMappingURL=AuthCookieManager.d.ts.map

package/dist/types/auth/cookies/authTime_cookie.d.ts

@@ -4,4 +4,3 @@ export type TernAUTCookie = {
     initialize: () => void;
 };
 export declare const createTernAUT: () => TernAUTCookie;
-//# sourceMappingURL=authTime_cookie.d.ts.map

package/dist/types/index.browser.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -1,10 +1,3 @@
-export { TernSecureAuth } from './instance/TernAuth';
-export type { TernAuth } from './instance/TernAuth';
-export { TernServerAuth } from './instance/TernAuthServer';
-export type { TernServerAuthOptions, AuthenticatedApp } from './instance/TernAuthServer';
-export { CoreApiClient, coreApiClient } from './instance/coreApiClient';
-export type { ApiResponse, ApiResponseJSON, RequestOptions, BeforeRequestHook, AfterResponseHook } from './instance/coreApiClient';
-export { SignIn, TernSecureBase, buildURL } from './resources/internal';
-export type { AuthErrorTree, TernSecureConfig, SignInFormValues, SignInProps, SignUpProps, SignInResponse, SignInForceRedirectUrl, SignUpForceRedirectUrl, SignInFallbackRedirectUrl, SignUpFallbackRedirectUrl, ResendEmailVerification, TernSecureUser, TernSecureState } from '@tern-secure/types';
-export { RedirectUrls } from './utils/redirectUrls';
-//# sourceMappingURL=index.d.ts.map
+import 'regenerator-runtime/runtime';
+import { TernSecureAuth } from './instance/ternsecure';
+export { TernSecureAuth };

package/dist/types/instance/c_coreApiClient.d.ts

@@ -4,6 +4,7 @@ export type ApiRequestInit = RequestInit & {
     path?: string;
     search?: ConstructorParameters<typeof URLSearchParams>[0];
     sessionId?: string;
+    pathPrefix?: string;
     url?: URL;
 };
 export interface ApiResponseJSON<T> {
@@ -24,7 +25,7 @@ export interface ApiRequestOptions {
     recoveryTimeoutMs?: number;
 }
 export interface ApiClientOptions {
-    domain?: string;
+    authDomain?: string;
     apiUrl?: string;
     frontendApi?: string;
     instanceType?: InstanceType;
@@ -55,4 +56,3 @@ export declare class HTTPError extends Error {
     constructor(status: number, url: string, body?: any | undefined);
 }
 export declare function createCoreApiClient(clientOptions: ApiClientOptions): ApiClient;
-//# sourceMappingURL=c_coreApiClient.d.ts.map

package/dist/types/instance/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const PRESERVED_QUERYSTRING_PARAMS: string[];
+export declare const SIGN_IN_INITIAL_VALUE_KEYS: string[];
+export declare const SIGN_UP_INITIAL_VALUE_KEYS: string[];

package/dist/types/instance/coreApiClient.d.ts

@@ -62,4 +62,3 @@ export declare class CoreApiClient {
     request<T>(init: ApiRequestInit, opts?: RequestOptions): Promise<ApiResponse<T>>;
 }
 export declare const coreApiClient: CoreApiClient;
-//# sourceMappingURL=coreApiClient.d.ts.map

package/dist/types/instance/events.d.ts

@@ -29,4 +29,3 @@ export declare const eventBus: {
     getListeners: <Event extends keyof InternalEvents>(event: Event) => Array<(...args: any[]) => void>;
 };
 export {};
-//# sourceMappingURL=events.d.ts.map

package/dist/types/instance/{TernAuth.d.ts → ternsecure.d.ts}

@@ -1,9 +1,20 @@
-import type { CreateActiveSession, InstanceType, ListenerCallback, NavigateOptions, SessionResource, SignedInSession, SignInRedirectOptions, SignInResource, SignOut, SignUpRedirectOptions, SignUpResource, TernAuthSDK, TernSecureAuth as TernSecureAuthInterface, TernSecureAuthOptions, TernSecureUser, UnsubscribeCallback } from '@tern-secure/types';
+import type { CreateActiveSession, DomainOrProxyUrl, InstanceType, ListenerCallback, NavigateOptions, SessionResource, SignedInSession, SignInProps, SignInRedirectOptions, SignInResource, SignOut, SignUpProps, SignUpRedirectOptions, SignUpResource, TernAuthSDK, TernSecureAuth as TernSecureAuthInterface, TernSecureAuthOptions, TernSecureUser, UnsubscribeCallback } from '@tern-secure/types';
 import type { Auth as TernAuth } from 'firebase/auth';
 import { AuthCookieManager } from '../resources/internal';
+import type { MountComponentRenderer } from '../ui/Renderer';
 import { type ApiClient } from './c_coreApiClient';
 export declare function inBrowser(): boolean;
 export { TernAuth };
+declare global {
+    interface Window {
+        TernSecure?: TernSecureAuth;
+        apiKey?: string;
+        apiUrl?: string;
+        authDomain: TernSecureAuthInterface['authDomain'];
+        frontEndDomain?: TernSecureAuthInterface['frontEndDomain'];
+        proxyUrl?: TernSecureAuthInterface['proxyUrl'];
+    }
+}
 /**
  * Firebase implementation of the TernSecureAuth interface
  */
@@ -11,6 +22,7 @@ export declare class TernSecureAuth implements TernSecureAuthInterface {
     #private;
     static version: string;
     static sdkMetadata: TernAuthSDK;
+    static mountComponentRenderer?: MountComponentRenderer;
     private static instance;
     private _currentUser;
     private signedInSession;
@@ -22,6 +34,9 @@ export declare class TernSecureAuth implements TernSecureAuthInterface {
     error: Error | null;
     user: TernSecureUser | null | undefined;
     __internal_country?: string | null;
+    customDomain?: string | undefined;
+    isVisible: boolean;
+    currentView: 'signIn' | 'signUp' | null;
     signIn: SignInResource | null | undefined;
     signUp: SignUpResource | null | undefined;
     session: SessionResource | null | undefined;
@@ -31,20 +46,29 @@ export declare class TernSecureAuth implements TernSecureAuthInterface {
     set sdkMetadata(metadata: TernAuthSDK);
     get sdkMetadata(): TernAuthSDK;
     get requiresVerification(): boolean;
+    load: (options?: TernSecureAuthOptions) => Promise<void>;
+    __unstable__updateProps: (_props: any) => Promise<void> | undefined;
+    assertComponentControlsReady(controls: unknown): asserts controls is ReturnType<MountComponentRenderer>;
+    showSignIn(node: HTMLDivElement, props?: SignInProps): void;
+    hideSignIn(node: HTMLDivElement): void;
+    showSignUp(node: HTMLDivElement, props?: SignUpProps): void;
+    hideSignUp(node: HTMLDivElement): void;
+    showUserButton(node: HTMLDivElement): void;
+    hideUserButton(node: HTMLDivElement): void;
     get apiUrl(): string;
-    get domain(): string;
+    get authDomain(): string;
     get instanceType(): InstanceType | undefined;
-    constructor(options?: TernSecureAuthOptions);
+    constructor(apiUrl: string, options?: DomainOrProxyUrl);
     getApiClient: () => ApiClient;
     setLoading(isLoading: boolean): void;
     authCookieManager(): AuthCookieManager | undefined;
     _internal_getOption<K extends keyof TernSecureAuthOptions>(key: K): TernSecureAuthOptions[K];
     _internal_getAllOptions(): Readonly<TernSecureAuthOptions>;
-    static getOrCreateInstance(options?: TernSecureAuthOptions): TernSecureAuth;
+    static getOrCreateInstance(apiUrl: string, options?: DomainOrProxyUrl): TernSecureAuth;
     static clearInstance(): void;
-    static initialize(options: TernSecureAuthOptions): TernSecureAuth;
+    static initialize(options?: TernSecureAuthOptions): TernSecureAuth;
     initialize: (options?: TernSecureAuthOptions) => Promise<void>;
-    static create(options: TernSecureAuthOptions): TernSecureAuth;
+    static create(options?: TernSecureAuthOptions): TernSecureAuth;
     private initializeFirebaseApp;
     signOut: SignOut;
     get currentSession(): SignedInSession | null;
@@ -63,6 +87,7 @@ export declare class TernSecureAuth implements TernSecureAuthInterface {
     createActiveSession: CreateActiveSession;
     navigate: (to: string | undefined, options?: NavigateOptions) => Promise<unknown>;
     constructUrlWithAuthRedirect: (to: string) => string;
+    constructAfterSignOutUrl: () => string;
     redirectToSignIn: (options?: SignInRedirectOptions) => Promise<unknown>;
     redirectToSignUp: (options?: SignUpRedirectOptions) => Promise<unknown>;
     redirectAfterSignIn: () => Promise<unknown>;
@@ -71,4 +96,3 @@ export declare class TernSecureAuth implements TernSecureAuthInterface {
     constructSignUpUrl: (options?: SignUpRedirectOptions) => string;
     __internal_setCountry: (country: string | null) => void;
 }
-//# sourceMappingURL=TernAuth.d.ts.map

package/dist/types/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/types/resources/Base.d.ts

@@ -1,3 +1,4 @@
+import type { TernSecureResourceJSON } from '@tern-secure/types';
 import type { ApiRequestInit, ApiResponseJSON } from '../instance/coreApiClient';
 import type { AuthCookieManager, TernSecureAuth } from './internal';
 export type HTTPMethod = 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
@@ -8,16 +9,27 @@ export type PostMutateParams = {
     path?: string;
     search?: ConstructorParameters<typeof URLSearchParams>[0];
 };
+export type BaseMutateParams = {
+    action?: string;
+    body?: any;
+    method?: HTTPMethod;
+    path?: string;
+};
 export declare abstract class TernSecureBase {
     static ternsecure: TernSecureAuth;
+    id?: string;
+    pathRoot: string;
     static get apiClient(): import("../instance/c_coreApiClient").ApiClient;
     static get authCookieManager(): AuthCookieManager | undefined;
     protected get authCookieManager(): AuthCookieManager | undefined;
+    isNew(): boolean;
     /**
      * Core method to fetch data from API endpoints using coreApiClient
      * This method handles the complete request lifecycle including error handling
      */
-    protected static fetchFromCoreApi<J>(requestInit: ApiRequestInit): Promise<ApiResponseJSON<J> | null>;
+    protected static _baseFetchFromCoreApi<J extends TernSecureResourceJSON | null>(requestInit: ApiRequestInit): Promise<ApiResponseJSON<J> | null>;
+    protected path(action?: string): string;
+    protected abstract fromJSON(data: TernSecureResourceJSON | null): this;
     /**
      * Convenience method for making POST requests
      */
@@ -25,11 +37,12 @@ export declare abstract class TernSecureBase {
     /**
      * Instance method to fetch data from API endpoints
      */
-    protected fetchFromCoreApi(requestInit: ApiRequestInit): Promise<ApiResponseJSON<any> | null>;
+    protected _fetchFromCoreApi<J extends TernSecureResourceJSON>(requestInit: ApiRequestInit): Promise<ApiResponseJSON<any> | null>;
     /**
      * Instance method for making POST requests
      */
     protected basePost(params: PostMutateParams): Promise<ApiResponseJSON<any> | null>;
+    protected _baseMutate<J extends TernSecureResourceJSON>(params?: BaseMutateParams): Promise<this>;
     /**
      * Instance method to make GET requests
      * This is a convenience method that sets the HTTP method to GET
@@ -40,8 +53,8 @@ export declare abstract class TernSecureBase {
      * This is designed to be used by child classes like SignIn
      */
     protected _post(params: PostMutateParams): Promise<ApiResponseJSON<any> | null>;
+    protected _basePost<J extends TernSecureResourceJSON>(params?: BaseMutateParams): Promise<this>;
     static makeApiRequest(requestInit: ApiRequestInit): Promise<ApiResponseJSON<any> | null>;
     protected makeApiRequest(requestInit: ApiRequestInit): Promise<ApiResponseJSON<any> | null>;
     private static shouldRethrowofflineNetworkError;
 }
-//# sourceMappingURL=Base.d.ts.map

package/dist/types/resources/Error.d.ts

@@ -1,2 +1 @@
 export { TernSecureAPIResponseError, TernSecureRuntimeError, } from "@tern-secure/shared/errors-api";
-//# sourceMappingURL=Error.d.ts.map

package/dist/types/resources/Session.d.ts

@@ -1,4 +1,4 @@
-import type { IdTokenResult, SessionJson, SessionResource, SessionStatus, TernSecureUser } from '@tern-secure/types';
+import type { IdTokenResult, SessionJson, SessionResource, SessionStatus, TernSecureResourceJSON, TernSecureUser } from '@tern-secure/types';
 import { TernSecureBase } from './Base';
 /**
  * Enhanced Session class that handles custom token authentication for client-server sync.
@@ -45,5 +45,5 @@ export declare class Session extends TernSecureBase implements SessionResource {
      * Convert session to plain object for serialization
      */
     toJSON(): SessionJson;
+    protected fromJSON(data: SessionJson | TernSecureResourceJSON | null): this;
 }
-//# sourceMappingURL=Session.d.ts.map

package/dist/types/resources/SignIn.d.ts

@@ -1,5 +1,5 @@
-import type { ResendEmailVerification, SignInFormValues, SignInResource, SignInResponse as SignInResponseFromTypes, SignInStatus, SocialProviderOptions } from '@tern-secure/types';
-import type { Auth, UserCredential } from 'firebase/auth';
+import type { AttemptFirstFactorParams, SignInCreateParams, SignInFirstFactor, SignInJson, SignInPasswordParams, SignInPhoneParams, SignInResource, SignInResponse as SignInResponseFromTypes, SignInStatus, SignInVerificationResponse, SocialProviderOptions, TernSecureUser } from '@tern-secure/types';
+import type { ApplicationVerifier, Auth, UserCredential } from 'firebase/auth';
 import { TernSecureBase } from './Base';
 type SignInResponse = SignInResponseFromTypes;
 export type TernRequestInit = RequestInit;
@@ -13,18 +13,35 @@ export type SignInParams = {
 export type SupportedProvider = 'google' | 'apple' | 'microsoft' | 'github' | 'twitter' | 'facebook' | string;
 export declare class SignIn extends TernSecureBase implements SignInResource {
     pathRoot: string;
+    pathSessionRoot: string;
+    id?: string;
     status: SignInStatus | null;
+    supportedFirstFactors: SignInFirstFactor[] | null;
+    identifier: string | null;
     private auth;
     private csrfToken;
     private _currentUser;
-    constructor(auth: Auth, csrfToken: string | undefined);
-    signInWithCredential: (credential: UserCredential) => Promise<import("..").ApiResponseJSON<any> | null>;
-    withEmailAndPassword: (params: SignInFormValues) => Promise<SignInResponse>;
-    withCredential: (params: SignInFormValues) => Promise<void>;
-    withSocialProvider: (provider: SupportedProvider, options?: SocialProviderOptions) => Promise<SignInResponse>;
+    private _confirmationResult;
+    constructor(data: (SignInJson | null) | undefined, auth: Auth, csrfToken: string | undefined);
+    get user(): TernSecureUser | null;
+    create: (params: SignInCreateParams) => Promise<this>;
+    attemptFirstFactor: (params: AttemptFirstFactorParams) => Promise<SignInResource>;
+    attemptPhoneNumberVerification: (params: {
+        code: string;
+    }) => Promise<SignInResource>;
+    signInWithCredential: (credential: UserCredential) => Promise<import("../instance/coreApiClient").ApiResponseJSON<any> | null>;
+    authenticateWithPassword: (params: SignInPasswordParams) => Promise<SignInResponse>;
+    createRecaptchaVerifier: (containerOrId: string | HTMLElement, parameters?: any) => ApplicationVerifier;
+    authenticateWithPhoneNumber: (params: SignInPhoneParams) => Promise<SignInResponse>;
+    withCredential: (params: SignInPasswordParams) => Promise<void>;
+    authenticateWithSocialProvider: (provider: SupportedProvider, options?: SocialProviderOptions) => Promise<SignInResponse>;
     completeMfaSignIn: (_mfaToken: string, _mfaContext?: any) => Promise<SignInResponse>;
-    sendPasswordResetEmail: (email: string) => Promise<void>;
-    resendEmailVerification: () => Promise<ResendEmailVerification>;
+    sendPasswordResetEmail: (email: string) => Promise<import("../instance/coreApiClient").ApiResponseJSON<any> | null>;
+    private resendEmailVerification;
+    attemptEmailVerification: (options?: {
+        url?: string;
+        handleCodeInApp?: boolean;
+    }) => Promise<SignInVerificationResponse>;
     private getProviderConfig;
     private authRedirectResult;
     /**
@@ -50,6 +67,6 @@ export declare class SignIn extends TernSecureBase implements SignInResource {
     private _signInWithRedirect;
     private _signInWithPopUp;
     checkRedirectResult(): Promise<SignInResponse | null>;
+    protected fromJSON(data: SignInJson | null): this;
 }
 export {};
-//# sourceMappingURL=SignIn.d.ts.map

package/dist/types/resources/SignUp.d.ts

@@ -1,17 +1,19 @@
-import type { SignUpInitialValue, SignUpResource, SignUpResponse, SignUpStatus } from '@tern-secure/types';
+import type { SignUpFormValues, SignUpJson, SignUpResource, SignUpStatus, TernSecureUser, UnverifiedField } from '@tern-secure/types';
 import type { Auth } from 'firebase/auth';
 import { TernSecureBase } from './Base';
 export declare class SignUp extends TernSecureBase implements SignUpResource {
     status: SignUpStatus | null;
-    username: string | null;
-    firstName: string | null;
-    lastName: string | null;
-    displayName: string | null;
-    email: string | null;
-    phoneNumber: string | null;
+    user: TernSecureUser | null;
+    unverifiedFields?: UnverifiedField[];
+    message?: string;
+    error?: any;
     private auth;
-    constructor(auth: Auth);
-    withEmailAndPassword: (params: SignUpInitialValue) => Promise<SignUpResponse>;
+    constructor(data: (SignUpJson | null) | undefined, auth: Auth);
+    withEmailAndPassword: (params: SignUpFormValues) => Promise<SignUpResource>;
     withSocialProvider(): Promise<void>;
+    attemptEmailVerification: (options?: {
+        url?: string;
+        handleCodeInApp?: boolean;
+    }) => Promise<SignUpResource>;
+    protected fromJSON(data: SignUpJson | null): this;
 }
-//# sourceMappingURL=SignUp.d.ts.map

package/dist/types/resources/internal.d.ts

@@ -1,4 +1,4 @@
-export type { TernSecureAuth } from '../instance/TernAuth';
+export type { TernSecureAuth } from '../instance/ternsecure';
 export * from './Session';
 export * from './SignUp';
 export * from './SignIn';
@@ -6,4 +6,3 @@ export * from './Base';
 export * from '../auth/AuthCookieManager';
 export * from '../utils';
 export * from './Error';
-//# sourceMappingURL=internal.d.ts.map

package/dist/types/ui/Renderer.d.ts

@@ -0,0 +1,26 @@
+import type { TernSecureAuth, TernSecureAuthOptions } from '@tern-secure/types';
+import type { TernSecureComponentName } from './lazyLoading/components';
+import type { AvailableComponentProps } from './types';
+export type TernComponentControls = {
+    mountComponent: (params: {
+        appearanceKey: string;
+        name: TernSecureComponentName;
+        node: HTMLDivElement;
+        props?: AvailableComponentProps;
+    }) => void;
+    unmountComponent: (params: {
+        node: HTMLDivElement;
+    }) => void;
+    updateProps: (params: {
+        appearanceKey?: string;
+        options?: TernSecureAuthOptions | undefined;
+        node: HTMLDivElement;
+        props?: unknown;
+    }) => void;
+};
+export declare const mountComponentRenderer: (ternsecure: TernSecureAuth, options: TernSecureAuthOptions) => {
+    ensureMounted: (opts?: {
+        preloadHint: TernSecureComponentName;
+    }) => Promise<TernComponentControls>;
+};
+export type MountComponentRenderer = typeof mountComponentRenderer;

package/dist/types/ui/common/ProviderInitialIcon.d.ts

@@ -0,0 +1,6 @@
+type ProviderInitialIconProps = {
+    id: string;
+    className?: string;
+};
+export declare const ProviderInitialIcon: ({ id, className }: ProviderInitialIconProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/ui/common/VerificationCodeCard.d.ts

@@ -0,0 +1,12 @@
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+export type VerificationCodeCardProps = {
+    cardTitle?: string;
+    cardDescription?: string;
+    inputLabel?: string;
+    submitButtonText?: string;
+    onCodeEntryFinishedAction: (code: string, resolve: () => Promise<void>, reject: (err: unknown) => Promise<void>) => void;
+    onResendCodeClicked?: React.MouseEventHandler;
+    onBackLinkClicked?: React.MouseEventHandler;
+};
+export declare const VerificationCodeCard: (props: PropsWithChildren<VerificationCodeCardProps>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/common/VerificationLinkCard.d.ts

@@ -0,0 +1,7 @@
+type VerificationLinkCardProps = {
+    emailSent?: boolean;
+    onResend?: () => Promise<void>;
+    isLoading?: boolean;
+};
+export declare const VerificationLinkCard: (props: VerificationLinkCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/ui/common/constants.d.ts

@@ -0,0 +1,8 @@
+import type { Attribute } from '@tern-secure/types';
+export type SignInStartIdentifier = 'email_address' | 'phone_number';
+export declare const groupIdentifiers: (attributes: Attribute[]) => SignInStartIdentifier[];
+export declare const getIdentifiers: (identifier: SignInStartIdentifier) => {
+    fieldName: string;
+    label: string;
+    placeholder: string;
+};

package/dist/types/ui/common/index.d.ts

@@ -0,0 +1,3 @@
+export type { SignInStartIdentifier, } from './constants';
+export { getIdentifiers, groupIdentifiers, } from './constants';
+export { ProviderInitialIcon } from './ProviderInitialIcon';

package/dist/types/ui/components/sign-in/ResetPassword.d.ts

@@ -0,0 +1 @@
+export declare const PasswordReset: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-in/ResetPasswordSuccess.d.ts

@@ -0,0 +1 @@
+export declare function PasswordResetSuccess(): import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-in/SignIn.d.ts

@@ -0,0 +1,4 @@
+import type { SignInModalProps, SignInProps } from '@tern-secure/types';
+import React from 'react';
+export declare const SignIn: React.ComponentType<SignInProps>;
+export declare const SignInModal: (props: SignInModalProps) => React.JSX.Element;

package/dist/types/ui/components/sign-in/SignInEmailLinkCard.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function SignInEmailLinkCard(): React.JSX.Element;

package/dist/types/ui/components/sign-in/SignInFactorOne.d.ts

@@ -0,0 +1 @@
+export declare const SignInFactorOne: (props: unknown) => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-in/SignInFactorOneCodeForm.d.ts

@@ -0,0 +1,7 @@
+import type { EmailCodeFactor, PhoneCodeFactor } from '@tern-secure/types';
+import type { VerificationCodeCardProps } from '../../common/VerificationCodeCard';
+export type SignInFactorOneCodeCard = Pick<VerificationCodeCardProps, 'onBackLinkClicked'> & {
+    factor: EmailCodeFactor | PhoneCodeFactor;
+};
+export type SignInFactorOneCodeFormProps = SignInFactorOneCodeCard;
+export declare const SignInFactorOneCodeForm: (props: SignInFactorOneCodeFormProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-in/SignInFactorOnePasswordCard.d.ts

@@ -0,0 +1,6 @@
+type SignInFactorOnePasswordProps = {
+    signInWithPassword: (password: string) => Promise<void>;
+    onForgotPassword?: () => void;
+};
+export declare const SignInFactorOnePasswordCard: (props: SignInFactorOnePasswordProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/ui/components/sign-in/SignInFactorOnePhoneCodeCard.d.ts

@@ -0,0 +1,7 @@
+import type { PhoneCodeFactor } from '@tern-secure/types';
+import type { SignInFactorOneCodeCard } from './SignInFactorOneCodeForm';
+type SignInFactorOnePhoneCodeCardProps = SignInFactorOneCodeCard & {
+    factor: PhoneCodeFactor;
+};
+export declare const SignInFactorOnePhoneCodeCard: (props: SignInFactorOnePhoneCodeCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/ui/components/sign-in/SignInPassword.d.ts

@@ -0,0 +1,8 @@
+interface SignInPasswordProps {
+    onError?: (error: Error) => void;
+    isDisabled?: boolean;
+    signInWithPassword?: (email: string, password: string) => Promise<void>;
+    onForgotPassword?: () => void;
+}
+export declare const SignInPassword: (props: SignInPasswordProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/ui/components/sign-in/SignInSocialButtons.d.ts

@@ -0,0 +1 @@
+export declare const SignInSocialButtons: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-in/SignInStart.d.ts

@@ -0,0 +1,7 @@
+export type SessionErrorCode = 'ENDPOINT_NOT_FOUND' | 'COOKIE_SET_FAILED' | 'API_REQUEST_FAILED' | 'NETWORK_ERROR' | 'UNAUTHORIZED' | 'UNKNOWN_ERROR';
+export interface SessionError {
+    code: SessionErrorCode;
+    message: string;
+    original?: unknown;
+}
+export declare const SignInStart: (props: unknown) => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-in/SignInVerifyEmail.d.ts

@@ -0,0 +1 @@
+export declare const SignInVerifyEmail: (props: unknown) => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-in/index.d.ts

@@ -0,0 +1,4 @@
+import '../../../index.css';
+export * from './SignIn';
+export * from './ResetPassword';
+export * from './ResetPasswordSuccess';

package/dist/types/ui/components/sign-up/SignUp.d.ts

@@ -0,0 +1,8 @@
+import type { SignUpModalProps } from '@tern-secure/types';
+import React from 'react';
+import type { SignUpProps } from '../../types';
+import { SignUpStart } from './SignUpStart';
+import { SignUpVerifyEmail } from './SignUpVerifyEmail';
+export declare const SignUp: React.ComponentType<SignUpProps>;
+export declare const SignUpModal: (props: SignUpModalProps) => React.JSX.Element;
+export { SignUpStart, SignUpVerifyEmail };

package/dist/types/ui/components/sign-up/SignUpEmailLinkCard.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function SignUpEmailLinkCard(): React.JSX.Element;

package/dist/types/ui/components/sign-up/SignUpSocialButtons.d.ts

@@ -0,0 +1 @@
+export declare const SignUpSocialButtons: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-up/SignUpStart.d.ts

@@ -0,0 +1 @@
+export declare const SignUpStart: (props: unknown) => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-up/SignUpVerifyEmail.d.ts

@@ -0,0 +1 @@
+export declare const SignUpVerifyEmail: (props: unknown) => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/components/sign-up/index.d.ts

@@ -0,0 +1,2 @@
+import '../../../index.css';
+export * from './SignUp';

package/dist/types/ui/components/sign-up/util.d.ts

@@ -0,0 +1,14 @@
+import type { SignUpResource } from '@tern-secure/types';
+type CompleteSignUpFlowProps = {
+    signUp: SignUpResource;
+    verifyEmailPath?: string;
+    verifyPhonePath?: string;
+    continuePath?: string;
+    navigate: (to: string) => Promise<unknown>;
+    handleComplete?: () => Promise<void>;
+    redirectUrl?: string;
+    redirectUrlComplete?: string;
+    oidcPrompt?: string;
+};
+export declare const completeSignUpFlow: ({ signUp, verifyEmailPath, navigate, handleComplete }: CompleteSignUpFlowProps) => Promise<unknown> | undefined;
+export {};

package/dist/types/ui/components/user-button/index.d.ts

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

package/dist/types/ui/components/user-button/userButton.d.ts

@@ -0,0 +1 @@
+export declare function UserButton(): import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/ctx/TernAuthContext.d.ts

@@ -0,0 +1,4 @@
+import type { SignInResource, SignUpResource, TernSecureUser } from '@tern-secure/types';
+export declare function useAuthSignIn(): SignInResource | undefined | null;
+export declare function useAuthSignUp(): SignUpResource | undefined | null;
+export declare function useAuthUser(): TernSecureUser | null;

package/dist/types/ui/ctx/TernAuthUIComponentCtx.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { AvailableComponentName, AvailableComponentProps } from '../types';
+export declare function TernAuthUIComponentProvider({ componentName, props, children, }: {
+    componentName: AvailableComponentName;
+    props: AvailableComponentProps;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export * from './components';

package/dist/types/ui/ctx/TernSecureContextWrapper.d.ts

@@ -0,0 +1,8 @@
+import type { TernSecureAuth } from '@tern-secure/types';
+import React from 'react';
+type TernSecureContextWrapperProps = {
+    ternsecure: TernSecureAuth;
+    children: React.ReactNode;
+};
+export declare function TernSecureContextWrapper(props: TernSecureContextWrapperProps): React.JSX.Element | null;
+export {};

package/dist/types/ui/ctx/TernSecureOptions.d.ts

@@ -0,0 +1,10 @@
+import type { TernSecureAuthOptions } from '@tern-secure/types';
+import React from 'react';
+export declare const TernSecureAuthOptionsCtx: React.Context<TernSecureAuthOptions>;
+interface OptionsProviderProps {
+    children: React.ReactNode;
+    value: TernSecureAuthOptions;
+}
+declare function TernSecureOptionsProvider({ children, value }: OptionsProviderProps): import("react/jsx-runtime").JSX.Element;
+declare function useTernSecureOptions(): TernSecureAuthOptions;
+export { useTernSecureOptions, TernSecureOptionsProvider };

package/dist/types/ui/ctx/components/SignIn.d.ts

@@ -0,0 +1,21 @@
+import type { AuthErrorTree, TernSecureUser } from '@tern-secure/types';
+import type { ParsedQueryString } from '../../router';
+import type { SignInCtx } from '../../types';
+export type SignInContextType = Omit<SignInCtx, 'fallbackRedirectUrl' | 'forceRedirectUrl'> & {
+    onSignInSuccess: (user: TernSecureUser, options?: {
+        onPreRedirect?: () => Promise<boolean>;
+    }) => void;
+    handleSignInError: (error: AuthErrorTree) => void;
+    redirectAfterSignIn: () => any;
+    queryParams: ParsedQueryString;
+    signInUrl: string;
+    signUpUrl: string;
+    authQueryString: string | null;
+    afterSignUpUrl: string;
+    afterSignInUrl: string;
+    checkRedirectResult: () => Promise<void>;
+    isCombinedFlow: boolean;
+    showCombinedForm: boolean;
+};
+export declare const SignInContext: import("react").Context<SignInCtx | null>;
+export declare const useSignInContext: () => SignInContextType;

package/dist/types/ui/ctx/components/SignUp.d.ts

@@ -0,0 +1,14 @@
+import type { ParsedQueryString } from '../../router';
+import type { SignUpCtx } from '../../types';
+export type SignUpContextType = Omit<SignUpCtx, 'fallbackRedirectUrl' | 'forceRedirectUrl'> & {
+    navigateAfterSignUp: () => any;
+    queryParams: ParsedQueryString;
+    authQueryString: string | null;
+    signInUrl: string;
+    signUpUrl: string;
+    afterSignUpUrl: string;
+    afterSignInUrl: string;
+    shouldShowForm?: boolean;
+};
+export declare const SignUpContext: import("react").Context<SignUpCtx | null>;
+export declare const useSignUpContext: () => SignUpContextType;