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

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

@@ -0,0 +1,10 @@
+import type { UserButtonCtx } from '../../types';
+export declare const UserButtonContext: import("react").Context<UserButtonCtx | null>;
+export declare const useUserButtonContext: () => {
+    componentName: "UserButton";
+    navigateAfterSignOut: () => Promise<unknown>;
+    signInUrl: string | undefined;
+    showName?: boolean;
+    defaultOpen?: boolean;
+    mode?: "modal" | "mounted";
+};

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

@@ -0,0 +1,3 @@
+export * from './SignIn';
+export * from './SignUp';
+export * from './UserButton';

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

@@ -0,0 +1,4 @@
+export * from './TernSecureContextWrapper';
+export * from './TernAuthContext';
+export * from './TernSecureOptions';
+export * from './TernAuthUIComponentCtx';

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

@@ -0,0 +1,3 @@
+import type { SignInFactor } from '@tern-secure/types';
+export declare function getInitialValuesFromQueryParams(queryString: string, params: string[]): Record<string, string>;
+export declare function determineCurrentFactor(selectedFactor: SignInFactor | null, supportedFirstFactors: SignInFactor[] | null | undefined): SignInFactor | null;

package/dist/types/ui/customize/FieldControl.d.ts

@@ -0,0 +1,15 @@
+export interface FieldProps {
+    field?: string;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+}
+export interface PasswordFieldProps extends FieldProps {
+    onForgotPassword?: () => void;
+}
+declare const TernFieldErrors: () => import("react/jsx-runtime").JSX.Element | null;
+declare const TernTextField: ({ label, placeholder, disabled, required }: FieldProps) => import("react/jsx-runtime").JSX.Element;
+declare const TernPasswordField: ({ label, placeholder, disabled, required, onForgotPassword, }: PasswordFieldProps) => import("react/jsx-runtime").JSX.Element;
+declare const TernEmailField: ({ label, placeholder, disabled, required }: FieldProps) => import("react/jsx-runtime").JSX.Element;
+export { TernTextField, TernPasswordField, TernEmailField, TernFieldErrors };

package/dist/types/ui/customize/FieldLabelControl.d.ts

@@ -0,0 +1,11 @@
+export interface FieldProps {
+    field?: string;
+    label?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+}
+export declare function FieldErrors(): import("react/jsx-runtime").JSX.Element | null;
+export declare function TextField({ label, placeholder, disabled, required }: FieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function PasswordField({ label, placeholder, disabled, required }: FieldProps): import("react/jsx-runtime").JSX.Element;
+export declare function EmailField({ label, placeholder, disabled, required }: FieldProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/customize/Form.d.ts

@@ -0,0 +1,36 @@
+import { EmailField, PasswordField } from './FieldLabelControl';
+declare const fieldContext: import("react").Context<import("@tanstack/react-form").AnyFieldApi>, useFieldContext: <TData>() => import("@tanstack/react-form").FieldApi<any, string, TData, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>, formContext: import("react").Context<import("@tanstack/react-form").AnyFormApi>, useFormContext: () => import("@tanstack/react-form").ReactFormExtendedApi<Record<string, never>, any, any, any, any, any, any, any, any, any, any, any>;
+declare const useAppForm: <TFormData, TOnMount extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnChange extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnChangeAsync extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TOnBlur extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnBlurAsync extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TOnSubmit extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnSubmitAsync extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TOnDynamic extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnDynamicAsync extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TOnServer extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TSubmitMeta>(props: import("@tanstack/react-form").FormOptions<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta>) => import("@tanstack/react-form").AppFieldExtendedReactFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta, {
+    readonly EmailField: typeof EmailField;
+    readonly PasswordField: typeof PasswordField;
+    readonly TernEmailField: ({ label, placeholder, disabled, required }: import("./FieldControl").FieldProps) => import("react/jsx-runtime").JSX.Element;
+    readonly TernPasswordField: ({ label, placeholder, disabled, required, onForgotPassword, }: import("./FieldControl").PasswordFieldProps) => import("react/jsx-runtime").JSX.Element;
+    readonly TernTextField: ({ label, placeholder, disabled, required }: import("./FieldControl").FieldProps) => import("react/jsx-runtime").JSX.Element;
+}, {
+    readonly SubscribeButton: ({ label }: {
+        label: string;
+    }) => import("react/jsx-runtime").JSX.Element;
+}>, withForm: <TFormData, TOnMount extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnChange extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnChangeAsync extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TOnBlur extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnBlurAsync extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TOnSubmit extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnSubmitAsync extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TOnDynamic extends import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined, TOnDynamicAsync extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TOnServer extends import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData> | undefined, TSubmitMeta, TRenderProps extends object = {}>({ render, props, }: import("@tanstack/react-form").WithFormProps<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TSubmitMeta, {
+    readonly EmailField: typeof EmailField;
+    readonly PasswordField: typeof PasswordField;
+    readonly TernEmailField: ({ label, placeholder, disabled, required }: import("./FieldControl").FieldProps) => import("react/jsx-runtime").JSX.Element;
+    readonly TernPasswordField: ({ label, placeholder, disabled, required, onForgotPassword, }: import("./FieldControl").PasswordFieldProps) => import("react/jsx-runtime").JSX.Element;
+    readonly TernTextField: ({ label, placeholder, disabled, required }: import("./FieldControl").FieldProps) => import("react/jsx-runtime").JSX.Element;
+}, {
+    readonly SubscribeButton: ({ label }: {
+        label: string;
+    }) => import("react/jsx-runtime").JSX.Element;
+}, TRenderProps>) => (props: import("react").PropsWithChildren<NoInfer<[unknown] extends [TRenderProps] ? any : TRenderProps> & {
+    form: import("@tanstack/react-form").AppFieldExtendedReactFormApi<[unknown] extends [TFormData] ? any : TFormData, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnMount] ? [TOnMount] extends [TOnMount & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnMount : TOnMount, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnChange] ? [TOnChange] extends [TOnChange & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnChange : TOnChange, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnChangeAsync] ? [TOnChangeAsync] extends [TOnChangeAsync & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnChangeAsync : TOnChangeAsync, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnBlur] ? [TOnBlur] extends [TOnBlur & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnBlur : TOnBlur, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnBlurAsync] ? [TOnBlurAsync] extends [TOnBlurAsync & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnBlurAsync : TOnBlurAsync, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnSubmit] ? [TOnSubmit] extends [TOnSubmit & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnSubmit : TOnSubmit, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnSubmitAsync] ? [TOnSubmitAsync] extends [TOnSubmitAsync & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnSubmitAsync : TOnSubmitAsync, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnDynamic] ? [TOnDynamic] extends [TOnDynamic & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnDynamic : TOnDynamic, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnDynamicAsync] ? [TOnDynamicAsync] extends [TOnDynamicAsync & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnDynamicAsync : TOnDynamicAsync, [import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined] extends [TOnServer] ? [TOnServer] extends [TOnServer & (import("@tanstack/react-form").FormValidateOrFn<TFormData> | undefined)] ? any : TOnServer : TOnServer, [unknown] extends [TSubmitMeta] ? any : TSubmitMeta, {
+        readonly EmailField: typeof EmailField;
+        readonly PasswordField: typeof PasswordField;
+        readonly TernEmailField: ({ label, placeholder, disabled, required }: import("./FieldControl").FieldProps) => import("react/jsx-runtime").JSX.Element;
+        readonly TernPasswordField: ({ label, placeholder, disabled, required, onForgotPassword, }: import("./FieldControl").PasswordFieldProps) => import("react/jsx-runtime").JSX.Element;
+        readonly TernTextField: ({ label, placeholder, disabled, required }: import("./FieldControl").FieldProps) => import("react/jsx-runtime").JSX.Element;
+    }, {
+        readonly SubscribeButton: ({ label }: {
+            label: string;
+        }) => import("react/jsx-runtime").JSX.Element;
+    }>;
+}>) => import("react").ReactNode;
+export { fieldContext, useFieldContext, formContext, useAppForm, withForm, useFormContext };

package/dist/types/ui/elements/CodeControl.d.ts

@@ -0,0 +1,47 @@
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+type onCodeEntryFinishedCallback = (code: string) => unknown;
+type onCodeEntryFinished = (cb: onCodeEntryFinishedCallback) => void;
+type onCodeEntryFinishedActionCallback<R = unknown> = (code: string, resolve: (params?: R) => Promise<void>, reject: (err: unknown) => Promise<void>) => void;
+type OTPControl = {
+    otpInputProps: {
+        length: number;
+        values: string[];
+        setValues: React.Dispatch<React.SetStateAction<string[]>>;
+        feedback: string | null;
+        feedbackType: 'error' | 'success' | null;
+        clearFeedback: () => void;
+        ref: React.MutableRefObject<any>;
+    };
+    onCodeEntryFinished: onCodeEntryFinished;
+    reset: () => void;
+    setError: (msg: string) => void;
+};
+type UseFieldOTP = <R = unknown>(params: {
+    id?: 'code';
+    onCodeEntryFinished: onCodeEntryFinishedActionCallback<R>;
+    onResendCodeClicked?: React.MouseEventHandler;
+    onResolve?: (a?: R) => Promise<void> | void;
+}) => {
+    isLoading: boolean;
+    onResendCode: React.MouseEventHandler<HTMLButtonElement> | undefined;
+    onFakeContinue: () => void;
+    otpControl: OTPControl;
+};
+export declare const useFieldOTP: UseFieldOTP;
+export type OTPInputProps = {
+    label?: string;
+    resendButton?: string;
+    description?: string;
+    isLoading: boolean;
+    isDisabled?: boolean;
+    onResendCode?: React.MouseEventHandler<HTMLButtonElement>;
+    otpControl: ReturnType<typeof useFieldOTP>['otpControl'];
+    centerAlign?: boolean;
+};
+export declare const OTPRoot: ({ children, ...props }: PropsWithChildren<OTPInputProps>) => import("react/jsx-runtime").JSX.Element;
+export declare const OTPResendButton: () => import("react/jsx-runtime").JSX.Element | null;
+export declare const OTPCodeControl: React.ForwardRefExoticComponent<React.RefAttributes<{
+    reset: any;
+}>>;
+export {};

package/dist/types/ui/elements/ErrorCard.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+type ErrorCardProps = {
+    cardTitle?: string;
+    cardSubtitle?: string;
+    message?: string;
+    onBackLinkClick?: React.MouseEventHandler | undefined;
+    shouldNavigateBack?: boolean;
+};
+export declare const ErrorCard: (props: ErrorCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/ui/elements/LoadingCard.d.ts

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

package/dist/types/ui/elements/RouterLink.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+type ElementProps = {
+    div: React.JSX.IntrinsicElements['div'];
+    input: React.JSX.IntrinsicElements['input'];
+    button: React.JSX.IntrinsicElements['button'];
+    heading: React.JSX.IntrinsicElements['h1'];
+    p: React.JSX.IntrinsicElements['p'];
+    a: React.JSX.IntrinsicElements['a'];
+    label: React.JSX.IntrinsicElements['label'];
+    img: React.JSX.IntrinsicElements['img'];
+    form: React.JSX.IntrinsicElements['form'];
+    table: React.JSX.IntrinsicElements['table'];
+    thead: React.JSX.IntrinsicElements['thead'];
+    tbody: React.JSX.IntrinsicElements['tbody'];
+    th: React.JSX.IntrinsicElements['th'];
+    tr: React.JSX.IntrinsicElements['tr'];
+    td: React.JSX.IntrinsicElements['td'];
+    dl: React.JSX.IntrinsicElements['dl'];
+    dt: React.JSX.IntrinsicElements['dt'];
+    dd: React.JSX.IntrinsicElements['dd'];
+    hr: React.JSX.IntrinsicElements['hr'];
+};
+type PrimitiveProps<HtmlT extends keyof ElementProps> = ElementProps[HtmlT];
+type OwnProps = {
+    isExternal?: boolean;
+    isDisabled?: boolean;
+};
+type LinkProps = PrimitiveProps<'a'> & OwnProps;
+export declare const applyDataStateProps: (props: any) => {
+    'data-error': any;
+    'data-disabled': any;
+    'data-loading': any;
+    'data-open': any;
+    'data-active': any;
+};
+export declare const Link: (props: LinkProps) => React.JSX.Element;
+type PropsOfComponent<C extends (...args: any[]) => any> = Parameters<C>[0];
+type RouterLinkProps = PropsOfComponent<typeof Link> & {
+    to?: string;
+};
+export declare const RouterLink: (props: RouterLinkProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/ui/elements/SocialButtons.d.ts

@@ -0,0 +1,6 @@
+interface SocialButtonsProps {
+    onProviderClick: (provider: string) => void;
+    disabled?: boolean;
+}
+export declare const SocialButtons: ({ onProviderClick, disabled }: SocialButtonsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/ui/elements/TimerButton.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Button } from './button';
+type TimerButtonProps = React.ComponentProps<typeof Button> & {
+    throttleTimeInSec?: number;
+    startDisabled?: boolean;
+    showCounter?: boolean;
+};
+export declare const TimerButton: ({ onClick: onClickProp, children, startDisabled, throttleTimeInSec, showCounter, ...props }: TimerButtonProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/ui/elements/alert.d.ts

@@ -0,0 +1,8 @@
+import { type VariantProps } from "class-variance-authority";
+import * as React from "react";
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Alert, AlertTitle, AlertDescription };

package/dist/types/ui/elements/avatar.d.ts

@@ -0,0 +1,6 @@
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+import * as React from "react";
+declare function Avatar({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarFallback({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Fallback>): import("react/jsx-runtime").JSX.Element;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/types/ui/elements/button.d.ts

@@ -0,0 +1,10 @@
+import { type VariantProps } from "class-variance-authority";
+import * as React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };

package/dist/types/ui/elements/card.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare function Card({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

package/dist/types/ui/elements/ctx/CardStateCtx.d.ts

@@ -0,0 +1,26 @@
+import type { AuthErrorTree, SignInResponse } from '@tern-secure/types';
+import React, { type ReactNode } from 'react';
+type CardStatus = 'idle' | 'loading' | 'error' | 'success';
+type CardState = {
+    status: CardStatus;
+    error: SignInResponse | AuthErrorTree | null;
+};
+interface CardStateCtxValue extends CardState {
+    setCardState: (state: Partial<CardState>) => void;
+    setStatus: (status: CardStatus) => void;
+    setLoading: () => void;
+    setError: (error: SignInResponse | AuthErrorTree) => void;
+    setIdle: () => void;
+    clearError: () => void;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    isIdle: boolean;
+}
+declare const useCardState: () => CardStateCtxValue;
+type CardStateProviderProps = {
+    children: ReactNode;
+};
+declare function CardStateProvider({ children }: CardStateProviderProps): import("react/jsx-runtime").JSX.Element;
+export { CardStateProvider, useCardState };
+export declare const withCardStateProvider: <T>(Component: React.ComponentType<T>) => (props: T) => import("react/jsx-runtime").JSX.Element;

package/dist/types/ui/elements/ctx/index.d.ts

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

package/dist/types/ui/elements/field.d.ts

@@ -0,0 +1,24 @@
+import { type VariantProps } from "class-variance-authority";
+import { Label } from "./label";
+declare function FieldSet({ className, ...props }: React.ComponentProps<"fieldset">): import("react/jsx-runtime").JSX.Element;
+declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<"legend"> & {
+    variant?: "legend" | "label";
+}): import("react/jsx-runtime").JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare const fieldVariants: (props?: ({
+    orientation?: "vertical" | "horizontal" | "responsive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Field({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof fieldVariants>): import("react/jsx-runtime").JSX.Element;
+declare function FieldContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): import("react/jsx-runtime").JSX.Element;
+declare function FieldTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function FieldDescription({ className, ...props }: React.ComponentProps<"p">): import("react/jsx-runtime").JSX.Element;
+declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<"div"> & {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<"div"> & {
+    errors?: Array<{
+        message?: string;
+    } | undefined>;
+}): import("react/jsx-runtime").JSX.Element | null;
+export { Field, FieldLabel, FieldDescription, FieldError, FieldGroup, FieldLegend, FieldSeparator, FieldSet, FieldContent, FieldTitle, };

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

@@ -0,0 +1,16 @@
+export * from '../customize/FieldLabelControl';
+export * from '../customize/Form';
+export * from './card';
+export * from './ctx';
+export * from './field';
+export * from './separator';
+export * from './button';
+export * from './avatar';
+export * from './alert';
+export * from './input';
+export * from './label';
+export * from './LoadingCard';
+export * from './ErrorCard';
+export * from './SocialButtons';
+export * from './TimerButton';
+export * from './CodeControl';

package/dist/types/ui/elements/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/types/ui/elements/label.d.ts

@@ -0,0 +1,4 @@
+import * as LabelPrimitive from "@radix-ui/react-label";
+import * as React from "react";
+declare function Label({ className, ...props }: React.ComponentProps<typeof LabelPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Label };

package/dist/types/ui/elements/separator.d.ts

@@ -0,0 +1,4 @@
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import * as React from "react";
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Separator };

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

@@ -0,0 +1,6 @@
+export * from './useWindowEventListener';
+export * from './useFetch';
+export * from './useNavigateToFlowStart';
+export * from './useEmailLink';
+export * from './useSafeState';
+export * from './useLoadingStatus';

package/dist/types/ui/hooks/useEmailLink.d.ts

@@ -0,0 +1,11 @@
+export type VerificationStatus = 'unverified' | 'verified' | 'transferable' | 'failed' | 'expired';
+export interface SignInStartEmailLinkFlowParams extends StartEmailLinkFlowParams {
+    emailAddressId: string;
+}
+export interface StartEmailLinkFlowParams {
+    redirectUrl: string;
+}
+export type CreateEmailLinkFlowReturn<Params, Resource> = {
+    startEmailLinkFlow: (params: Params) => Promise<Resource>;
+    cancelEmailLinkFlow: () => void;
+};

package/dist/types/ui/hooks/useFetch.d.ts

@@ -0,0 +1,44 @@
+export type State<Data = any, Error = any> = {
+    data: Data | null;
+    error: Error | null;
+    /**
+     * if there's an ongoing request and no "loaded data"
+     */
+    isLoading: boolean;
+    /**
+     * if there's a request or revalidation loading
+     */
+    isValidating: boolean;
+    cachedAt?: number;
+};
+/**
+ * This utility should only be used in tests to clear previously fetched data
+ */
+export declare const clearFetchCache: () => void;
+export declare const useCache: <K = any, V = any>(key: K, serializer?: (key: unknown) => string) => {
+    getCache: () => State<V> | undefined;
+    setCache: (state: State<V> | ((params: State<V>) => State<V>)) => void;
+    clearCache: () => void;
+    subscribeCache: (callback: () => void) => () => void;
+};
+/**
+ * An in-house simpler alternative to useSWR
+ * @param fetcher If fetcher is undefined no action will be performed
+ * @param params
+ * @param options
+ * @param resourceId
+ */
+export declare const useFetch: <K, T>(fetcher: ((...args: any) => Promise<T>) | undefined, params: K, options?: {
+    throttleTime?: number;
+    onSuccess?: (data: T) => void;
+    staleTime?: number;
+}, resourceId?: string) => {
+    setCache: (state: State<T, any> | ((params: State<T, any>) => State<T, any>)) => void;
+    invalidate: () => void;
+    revalidate: () => void;
+    data?: T | null | undefined;
+    error?: any;
+    isLoading?: boolean | undefined;
+    isValidating?: boolean | undefined;
+    cachedAt?: number;
+};

package/dist/types/ui/hooks/useLoadingStatus.d.ts

@@ -0,0 +1,14 @@
+type Status = 'idle' | 'loading' | 'error';
+export declare const useLoadingStatus: <Metadata>(initialState?: {
+    status: Status;
+    metadata?: Metadata | undefined;
+}) => {
+    status: Status;
+    setIdle: (metadata?: Metadata) => void;
+    setError: (metadata?: Metadata) => void;
+    setLoading: (metadata?: Metadata) => void;
+    loadingMetadata: Metadata | undefined;
+    isLoading: boolean;
+    isIdle: boolean;
+};
+export {};

package/dist/types/ui/hooks/useNavigateToFlowStart.d.ts

@@ -0,0 +1,3 @@
+export declare const useNavigateToFlowStart: () => {
+    navigateToFlowStart: () => Promise<unknown>;
+};

package/dist/types/ui/hooks/useSafeState.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+/**
+ * Solves/ hides the "setState on unmounted component" warning
+ * In 99% of cases, there is no memory leak involved, but still an annoying warning
+ * For more info:
+ * https://github.com/reactwg/react-18/discussions/82
+ */
+export declare function useSafeState<S>(initialState: S | (() => S)): [S, React.Dispatch<React.SetStateAction<S>>];
+export declare function useSafeState<S = undefined>(): [S | undefined, React.Dispatch<React.SetStateAction<S | undefined>>];

package/dist/types/ui/hooks/useWindowEventListener.d.ts

@@ -0,0 +1,3 @@
+type EventType = keyof WindowEventMap;
+export declare const useWindowEventListener: (eventOrEvents: EventType | EventType[] | undefined, cb: () => void) => void;
+export {};

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

@@ -0,0 +1,13 @@
+/**
+ * TypeScript configuration (typings) is not correctly configured for all projects.
+ * Consequently, the files are correctly imported but the TS checker emits errors.
+ * The above no-check is safe, as webpack will not allow compilation if for example a file is not resolved.
+ */
+export { default as LoaderCircle } from './loader-circle.svg';
+export { default as MailCheck } from './mail-check.svg';
+export { default as ArrowRight } from './arrow-right.svg';
+export { default as ChevronLeft } from './chevron-left.svg';
+export { default as RefreshCw } from './refresh-cw.svg';
+export { default as AlertCircle } from './alert-circle.svg';
+export { default as Eye } from './eye.svg';
+export { default as EyeOff } from './eye-off.svg';

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

@@ -0,0 +1,2 @@
+import '../ctx/index';
+export { createRoot } from 'react-dom/client';

package/dist/types/ui/lazyLoading/components.d.ts

@@ -0,0 +1,11 @@
+export declare const SignIn: import("react").LazyExoticComponent<import("react").ComponentType<import("@tern-secure/types").SignInProps>>;
+export declare const SignInModal: import("react").LazyExoticComponent<(props: import("@tern-secure/types").SignInModalProps) => React.JSX.Element>;
+export declare const SignUp: import("react").LazyExoticComponent<import("react").ComponentType<import("@tern-secure/types").SignUpProps>>;
+export declare const UserButton: import("react").LazyExoticComponent<typeof import("../components/user-button").UserButton>;
+export declare const preloadComponent: (component: unknown) => Promise<typeof import("../components/sign-in") | typeof import("../components/sign-up") | typeof import("../components/user-button")>;
+export declare const TernSecureComponents: {
+    SignIn: import("react").LazyExoticComponent<import("react").ComponentType<import("@tern-secure/types").SignInProps>>;
+    SignUp: import("react").LazyExoticComponent<import("react").ComponentType<import("@tern-secure/types").SignUpProps>>;
+    UserButton: import("react").LazyExoticComponent<typeof import("../components/user-button").UserButton>;
+};
+export type TernSecureComponentName = keyof typeof TernSecureComponents;

package/dist/types/ui/lazyLoading/providersCtx.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+declare const Portal: React.LazyExoticComponent<typeof import("../portal").Portal>;
+type LazyComponentRendererProps = React.PropsWithChildren<{
+    node: PortalProps['node'];
+    componentName: any;
+    componentProps: any;
+    componentKey: string;
+}>;
+type PortalProps = Parameters<typeof Portal>[0];
+/**
+ * LazyProviders handles UI-specific context for lazily loaded components.
+ * This separates the UI rendering context from the instance context,
+ * making it easier to manage UI-specific concerns.
+ */
+type LazyProvidersProps = React.PropsWithChildren<{
+    ternsecure: any;
+    children: any;
+    options: any;
+}>;
+export declare const LazyProviders: (props: LazyProvidersProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * LazyComponentRenderer handles rendering a single component through a portal
+ * with proper Suspense and error boundaries.
+ */
+export declare const LazyComponentRenderer: (props: LazyComponentRendererProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+import type { RoutingOptions } from '@tern-secure/types';
+import React from 'react';
+import type { AvailableComponentCtx, AvailableComponentName } from '../types';
+type PortalProps<CtxType extends AvailableComponentCtx, PropsType = Omit<CtxType, 'componentName'>> = {
+    node: HTMLDivElement;
+    component: React.FunctionComponent<PropsType> | React.ComponentClass<PropsType, any>;
+    props?: PropsType & RoutingOptions;
+} & {
+    componentName: AvailableComponentName;
+};
+export declare function Portal<CtxType extends AvailableComponentCtx>({ props, component, componentName, node, }: PortalProps<CtxType>): React.ReactPortal;
+export {};

package/dist/types/ui/router/BaseRouter.d.ts

@@ -0,0 +1,21 @@
+import type { NavigateOptions } from '@tern-secure/types';
+import React from 'react';
+interface BaseRouterProps {
+    basePath: string;
+    startPath: string;
+    getPath: () => string;
+    getQueryString: () => string;
+    internalNavigate: (toURL: URL, options?: NavigateOptions) => Promise<any> | any;
+    refreshEvents?: Array<keyof WindowEventMap>;
+    preservedParams?: string[];
+    urlStateParam?: {
+        startPath: string;
+        path: string;
+        componentName: string;
+        clearUrlStateParam: () => void;
+        socialProvider: string;
+    };
+    children: React.ReactNode;
+}
+export declare const BaseRouter: ({ basePath, startPath, getPath, getQueryString, internalNavigate, refreshEvents, preservedParams, urlStateParam, children, }: BaseRouterProps) => React.JSX.Element;
+export {};

package/dist/types/ui/router/HashRouter.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const hashRouterBase = "TERNSECURE-ROUTER/HASH";
+interface HashRouterProps {
+    preservedParams?: string[];
+    children: React.ReactNode;
+}
+export declare const HashRouter: ({ preservedParams, children }: HashRouterProps) => React.JSX.Element;
+export {};

package/dist/types/ui/router/PathRouter.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface PathRouterProps {
+    basePath: string;
+    preservedParams?: string[];
+    children: React.ReactNode;
+}
+export declare const PathRouter: ({ basePath, preservedParams, children, }: PathRouterProps) => React.JSX.Element | null;
+export {};

package/dist/types/ui/router/Route.d.ts

@@ -0,0 +1,19 @@
+import type { TernSecureAuth } from '@tern-secure/types';
+import React from 'react';
+interface RouteGuardProps {
+    canActivate: (ternsecure: TernSecureAuth) => boolean;
+}
+interface UnSecureRooteProps {
+    path?: string;
+    index?: boolean;
+    flowStart?: boolean;
+    canActivate?: never;
+}
+type SecureRouteProps = {
+    path?: string;
+    index?: boolean;
+    flowStart?: boolean;
+} & RouteGuardProps;
+export type RouteProps = React.PropsWithChildren<UnSecureRooteProps | SecureRouteProps>;
+export declare function Route(props: RouteProps): React.JSX.Element | null;
+export {};