nucleus-core-ts 0.8.0

package/dist/fe/components/FormBuilder/theme/index.d.ts

@@ -0,0 +1,136 @@
+export declare const formBuilderTheme: {
+    readonly container: {
+        readonly base: "w-full";
+    };
+    readonly form: {
+        readonly base: "w-full";
+        readonly layout: {
+            readonly vertical: "flex flex-col";
+            readonly horizontal: "flex flex-row flex-wrap";
+            readonly inline: "flex flex-row flex-wrap items-end";
+        };
+    };
+    readonly fields: {
+        readonly base: "grid w-full";
+        readonly columns: {
+            readonly 1: "grid-cols-1";
+            readonly 2: "grid-cols-1 sm:grid-cols-2";
+            readonly 3: "grid-cols-1 sm:grid-cols-2 lg:grid-cols-3";
+            readonly 4: "grid-cols-1 sm:grid-cols-2 lg:grid-cols-4";
+            readonly 6: "grid-cols-1 sm:grid-cols-2 md:grid-cols-3 lg:grid-cols-6";
+            readonly 12: "grid-cols-1 sm:grid-cols-2 md:grid-cols-4 lg:grid-cols-6 xl:grid-cols-12";
+        };
+        readonly gap: {
+            readonly sm: "gap-3";
+            readonly md: "gap-4";
+            readonly lg: "gap-6";
+        };
+    };
+    readonly field: {
+        readonly container: {
+            readonly base: "flex flex-col";
+            readonly span: {
+                readonly 1: "col-span-1";
+                readonly 2: "col-span-1 sm:col-span-2";
+                readonly 3: "col-span-1 sm:col-span-2 lg:col-span-3";
+                readonly 4: "col-span-1 sm:col-span-2 lg:col-span-4";
+                readonly 6: "col-span-1 sm:col-span-2 md:col-span-3 lg:col-span-6";
+                readonly 12: "col-span-full";
+            };
+        };
+        readonly label: {
+            readonly base: "mb-1.5 text-sm font-medium";
+            readonly color: {
+                readonly light: "text-zinc-700";
+                readonly dark: "dark:text-zinc-300";
+            };
+            readonly required: "after:content-['*'] after:ml-0.5 after:text-red-500";
+            readonly disabled: "opacity-50 cursor-not-allowed";
+        };
+        readonly error: {
+            readonly base: "mt-1 text-xs";
+            readonly color: {
+                readonly light: "text-red-500";
+                readonly dark: "dark:text-red-400";
+            };
+        };
+        readonly helper: {
+            readonly base: "mt-1 text-xs";
+            readonly color: {
+                readonly light: "text-zinc-500";
+                readonly dark: "dark:text-zinc-400";
+            };
+        };
+    };
+    readonly actions: {
+        readonly base: "flex items-center mt-6";
+        readonly gap: {
+            readonly sm: "gap-2";
+            readonly md: "gap-3";
+            readonly lg: "gap-4";
+        };
+        readonly alignment: {
+            readonly left: "justify-start";
+            readonly center: "justify-center";
+            readonly right: "justify-end";
+            readonly between: "justify-between";
+        };
+    };
+    readonly header: {
+        readonly base: "mb-6";
+        readonly title: {
+            readonly base: "text-xl font-semibold";
+            readonly color: {
+                readonly light: "text-zinc-900";
+                readonly dark: "dark:text-white";
+            };
+        };
+        readonly description: {
+            readonly base: "mt-1 text-sm";
+            readonly color: {
+                readonly light: "text-zinc-500";
+                readonly dark: "dark:text-zinc-400";
+            };
+        };
+    };
+    readonly divider: {
+        readonly base: "w-full h-px my-4";
+        readonly color: {
+            readonly light: "bg-zinc-200";
+            readonly dark: "dark:bg-zinc-700";
+        };
+    };
+    readonly section: {
+        readonly base: "mb-6";
+        readonly title: {
+            readonly base: "text-sm font-medium uppercase tracking-wider mb-3";
+            readonly color: {
+                readonly light: "text-zinc-500";
+                readonly dark: "dark:text-zinc-400";
+            };
+        };
+    };
+    readonly animation: {
+        readonly field: {
+            readonly enter: {
+                readonly duration: 0.3;
+                readonly ease: "power2.out";
+                readonly stagger: 0.05;
+            };
+            readonly exit: {
+                readonly duration: 0.2;
+                readonly ease: "power2.in";
+            };
+            readonly error: {
+                readonly duration: 0.4;
+                readonly ease: "elastic.out(1, 0.5)";
+            };
+        };
+        readonly submit: {
+            readonly duration: 0.2;
+            readonly ease: "power2.out";
+        };
+    };
+};
+export type FormBuilderTheme = typeof formBuilderTheme;
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/FormBuilder/types/index.d.ts

@@ -0,0 +1,150 @@
+import type { ReactNode } from "react";
+import type { LocaleKey } from "../../DatePicker/types";
+import type { SelectOption } from "../../SelectBox/types";
+export type FormMode = "add" | "edit";
+export type FormSize = "sm" | "md" | "lg";
+export type FormLayout = "vertical" | "horizontal" | "inline";
+export type ColumnType = "integer" | "smallint" | "bigint" | "serial" | "smallserial" | "bigserial" | "real" | "doublePrecision" | "numeric" | "decimal" | "text" | "varchar" | "char" | "uuid" | "boolean" | "date" | "time" | "timestamp" | "timestamptz" | "interval" | "json" | "jsonb" | "bytea" | "inet" | "cidr" | "macaddr" | "macaddr8" | "bit" | "bitVarying" | "point" | "line" | "lseg" | "box" | "path" | "polygon" | "circle" | "tsvector" | "tsquery" | "xml" | "money" | "vector" | "geometry" | "geography" | "customType";
+export type ValidationFormat = "email" | "url" | "uuid" | "date" | "datetime" | "time" | "uri" | "ipv4" | "ipv6";
+export interface ColumnValidation {
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    format?: ValidationFormat;
+    customMessage?: string;
+}
+export interface ColumnReference {
+    table: string;
+    column?: string;
+    onDelete?: "cascade" | "restrict" | "no action" | "set null" | "set default";
+    onUpdate?: "cascade" | "restrict" | "no action" | "set null" | "set default";
+}
+export interface ColumnEnum {
+    name: string;
+    values: string[];
+}
+export interface NucleusColumn {
+    name: string;
+    type: ColumnType;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    nullable?: boolean;
+    notNull?: boolean;
+    unique?: boolean;
+    primaryKey?: boolean;
+    default?: unknown;
+    defaultRaw?: string;
+    references?: ColumnReference;
+    enumValues?: string[];
+    enum?: ColumnEnum;
+    validation?: ColumnValidation;
+    comment?: string;
+    generatedAlwaysAs?: string;
+    generatedAlwaysAsIdentity?: boolean;
+    generatedByDefaultAsIdentity?: boolean;
+}
+export interface FormFieldConfig<T = unknown> {
+    name?: string;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    required?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    hidden?: boolean;
+    order?: number;
+    span?: 1 | 2 | 3 | 4 | 6 | 12;
+    options?: SelectOption<T>[];
+    fetchOptions?: () => Promise<SelectOption<T>[]>;
+    defaultValue?: T;
+    transform?: (value: T) => T;
+    render?: (props: FormFieldRenderProps<T>) => ReactNode;
+    dependsOn?: string[];
+    showWhen?: (values: Record<string, unknown>) => boolean;
+}
+export interface FormFieldRenderProps<T = unknown> {
+    value: T;
+    onChange: (value: T) => void;
+    error?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+export interface FormBuilderProps<T extends Record<string, unknown>> {
+    columns: NucleusColumn[];
+    mode: FormMode;
+    initialValues?: Partial<T>;
+    onSubmit: (values: T) => void | Promise<void>;
+    onCancel?: () => void;
+    fieldConfigs?: Partial<Record<keyof T, FormFieldConfig>>;
+    excludeFields?: (keyof T)[];
+    includeFields?: (keyof T)[];
+    layout?: FormLayout;
+    size?: FormSize;
+    columns_grid?: 1 | 2 | 3 | 4 | 6 | 12;
+    gap?: "sm" | "md" | "lg";
+    submitText?: string;
+    cancelText?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    showRequiredIndicator?: boolean;
+    locale?: LocaleKey;
+    className?: string;
+    formClassName?: string;
+    fieldsClassName?: string;
+    actionsClassName?: string;
+    renderHeader?: () => ReactNode;
+    renderFooter?: (props: FormFooterRenderProps) => ReactNode;
+    renderField?: (column: NucleusColumn, config: FormFieldConfig, defaultRender: () => ReactNode) => ReactNode;
+}
+export interface FormFooterRenderProps {
+    isSubmitting: boolean;
+    isValid: boolean;
+    isDirty: boolean;
+    reset: () => void;
+    submit: () => void;
+}
+export interface FormFieldProps<T = unknown> {
+    column: NucleusColumn;
+    config: FormFieldConfig<T>;
+    value: T;
+    onChange: (value: T) => void;
+    error?: string;
+    size?: FormSize;
+    locale?: LocaleKey;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+export interface FormState<T extends Record<string, unknown>> {
+    values: Partial<T>;
+    errors: Partial<Record<keyof T, string>>;
+    touched: Partial<Record<keyof T, boolean>>;
+    isSubmitting: boolean;
+    isDirty: boolean;
+}
+export interface UseFormBuilderOptions<T extends Record<string, unknown>> {
+    columns: NucleusColumn[];
+    initialValues?: Partial<T>;
+    fieldConfigs?: Partial<Record<keyof T, FormFieldConfig>>;
+    onSubmit: (values: T) => void | Promise<void>;
+    validate?: (values: Partial<T>) => Partial<Record<keyof T, string>>;
+}
+export interface UseFormBuilderReturn<T extends Record<string, unknown>> {
+    state: FormState<T>;
+    setValue: (name: keyof T, value: unknown) => void;
+    setValues: (values: Partial<T>) => void;
+    setError: (name: keyof T, error: string) => void;
+    setErrors: (errors: Partial<Record<keyof T, string>>) => void;
+    setTouched: (name: keyof T, touched: boolean) => void;
+    reset: () => void;
+    submit: () => Promise<void>;
+    validate: () => boolean;
+    getFieldProps: (name: keyof T) => {
+        value: unknown;
+        onChange: (value: unknown) => void;
+        error?: string;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/FormBuilder/utils/cn.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=cn.d.ts.map

package/dist/fe/components/FormBuilder/utils/fieldMapping.d.ts

@@ -0,0 +1,12 @@
+import type { NucleusColumn, ValidationFormat } from "../types";
+export type InputTypeMapping = "text" | "number" | "email" | "password" | "url" | "tel" | "textarea" | "select" | "checkbox" | "date" | "datetime" | "time" | "json" | "hidden";
+export interface FieldMapping {
+    inputType: InputTypeMapping;
+    validationType?: ValidationFormat;
+}
+export declare function getFieldMapping(column: NucleusColumn): FieldMapping;
+export declare function getInputTypeFromFormat(format: ValidationFormat): InputTypeMapping;
+export declare function shouldExcludeField(column: NucleusColumn): boolean;
+export declare function getDefaultValue(column: NucleusColumn): unknown;
+export declare function formatLabel(name: string): string;
+//# sourceMappingURL=fieldMapping.d.ts.map

package/dist/fe/components/FormBuilder/utils/validation.d.ts

@@ -0,0 +1,11 @@
+import type { NucleusColumn } from "../types";
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+export declare function validateField(column: NucleusColumn, value: unknown, isRequired: boolean): string | undefined;
+export declare function validateForm<T extends Record<string, unknown>>(columns: NucleusColumn[], values: Partial<T>, fieldConfigs?: Partial<Record<keyof T, {
+    required?: boolean;
+}>>): Partial<Record<keyof T, string>>;
+export declare function isFormValid<T extends Record<string, unknown>>(errors: Partial<Record<keyof T, string>>): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/fe/components/LoginPage/components/LoginForm.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from "react";
+import type { LoginFormProps } from "../types";
+export declare function LoginForm({ loginAction, captchaGenerateAction, captchaConfig, showRememberMe, showForgotPassword, showSignUp, forgotPasswordHref, signUpHref, onForgotPassword, onSignUp, onSuccess, }: LoginFormProps): ReactElement;
+//# sourceMappingURL=LoginForm.d.ts.map

package/dist/fe/components/LoginPage/components/LoginHeader.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from "react";
+import type { LoginHeaderProps } from "../types";
+export declare function LoginHeader({ logo, title, subtitle, }: LoginHeaderProps): ReactElement;
+//# sourceMappingURL=LoginHeader.d.ts.map

package/dist/fe/components/LoginPage/components/LoginPage.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from "react";
+import type { LoginPageProps } from "../types";
+export declare function LoginPage({ variant: _variant, logo, title, subtitle, loggedInTitle, showRememberMe, showForgotPassword, showSignUp, forgotPasswordHref, signUpHref, loginAction, meAction, logoutAction, captchaGenerateAction, config, onForgotPassword, onSignUp, onSuccess, onLogout, showBackground, className, }: LoginPageProps): ReactElement;
+//# sourceMappingURL=LoginPage.d.ts.map

package/dist/fe/components/LoginPage/index.d.ts

@@ -0,0 +1,8 @@
+export { LoginForm } from "./components/LoginForm";
+export { LoginHeader } from "./components/LoginHeader";
+export { LoginPage } from "./components/LoginPage";
+export { useLoginStore } from "./store";
+export type { LoginPageTheme } from "./theme";
+export { extendLoginPageTheme, loginPageTheme } from "./theme";
+export type { LoginAction, LoginFeatureConfig, LoginFormData, LoginFormProps, LoginHeaderProps, LoginPageConfig, LoginPageProps, LoginPageVariant, LoginState, LogoutAction, MeAction, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/LoginPage/store/index.d.ts

@@ -0,0 +1,22 @@
+import type { LoginState } from "../types";
+type LoginMethods = {
+    [key: string]: unknown;
+    setEmail: (email: string) => void;
+    setPassword: (password: string) => void;
+    setRememberMe: (value: boolean) => void;
+    setLoading: (value: boolean) => void;
+    setError: (error: string | null) => void;
+    setCaptchaId: (id: string | null) => void;
+    setCaptchaAnswer: (answer: string) => void;
+    setAuthenticated: (isAuthenticated: boolean, user?: {
+        id: string;
+        email: string;
+    } | null) => void;
+    reset: () => void;
+};
+type LoginStoreState = LoginState & {
+    [key: string]: unknown;
+};
+export declare const useLoginStore: () => import("h-state").StoreType<LoginStoreState, LoginMethods>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/LoginPage/theme/index.d.ts

@@ -0,0 +1,55 @@
+export type LoginPageTheme = {
+    container: {
+        base: string;
+        wrapper: string;
+    };
+    card: {
+        base: string;
+        padding: string;
+        background: string;
+        border: string;
+        shadow: string;
+        rounded: string;
+    };
+    header: {
+        container: string;
+        logoWrapper: string;
+        title: string;
+        subtitle: string;
+    };
+    form: {
+        container: string;
+        spacing: string;
+    };
+    input: {
+        wrapper: string;
+    };
+    checkbox: {
+        wrapper: string;
+        label: string;
+    };
+    links: {
+        container: string;
+        forgotPassword: string;
+        signUp: {
+            wrapper: string;
+            text: string;
+            link: string;
+        };
+    };
+    button: {
+        wrapper: string;
+    };
+    error: {
+        container: string;
+        text: string;
+    };
+    divider: {
+        container: string;
+        line: string;
+        text: string;
+    };
+};
+export declare const loginPageTheme: LoginPageTheme;
+export declare function extendLoginPageTheme(overrides: Partial<LoginPageTheme>): LoginPageTheme;
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/LoginPage/types/index.d.ts

@@ -0,0 +1,129 @@
+import type { CaptchaAction, CaptchaChallenge, CaptchaConfig } from "../../Captcha";
+export type LoginPageVariant = "default" | "minimal" | "split";
+export type LoginFormData = {
+    email: string;
+    password: string;
+    rememberMe: boolean;
+    captchaId?: string;
+    captchaAnswer?: string;
+};
+export type LoginAction<TData = unknown, TError = unknown> = {
+    start: (config: {
+        payload: {
+            email: string;
+            password: string;
+            rememberMe?: boolean;
+            captchaId?: string;
+            captchaAnswer?: string;
+        };
+        onAfterHandle?: (data: TData) => void;
+        onErrorHandle?: (error: TError, code?: number | null) => void;
+    }) => void;
+    state: {
+        isPending: boolean;
+        data: TData | null;
+        error: TError | null;
+    };
+};
+export type MeAction<TData = unknown, TError = unknown> = {
+    start: (config: {
+        payload: undefined;
+        onAfterHandle?: (data: TData) => void;
+        onErrorHandle?: (error: TError, code?: number | null) => void;
+    }) => void;
+    state: {
+        isPending: boolean;
+        data: TData | null;
+        error: TError | null;
+    };
+};
+export type LogoutAction<TData = unknown, TError = unknown> = {
+    start: (config: {
+        payload: undefined;
+        onAfterHandle?: (data: TData) => void;
+        onErrorHandle?: (error: TError, code?: number | null) => void;
+    }) => void;
+    state: {
+        isPending: boolean;
+        data: TData | null;
+        error: TError | null;
+    };
+};
+export type LoginFeatureConfig = {
+    redirectUrl?: string;
+    captcha?: CaptchaConfig;
+};
+export type LoginPageConfig = {
+    variant?: LoginPageVariant;
+    logo?: React.ReactNode;
+    title?: string;
+    subtitle?: string;
+    loggedInTitle?: string;
+    loggedInSubtitle?: string;
+    showRememberMe?: boolean;
+    showForgotPassword?: boolean;
+    showSignUp?: boolean;
+    forgotPasswordHref?: string;
+    signUpHref?: string;
+    loginAction: LoginAction;
+    meAction?: MeAction;
+    logoutAction?: LogoutAction;
+    captchaGenerateAction?: CaptchaAction<CaptchaChallenge>;
+    config?: {
+        login?: LoginFeatureConfig;
+    };
+    onForgotPassword?: () => void;
+    onSignUp?: () => void;
+    onSuccess?: () => void;
+    onLogout?: () => void;
+    showBackground?: boolean;
+    className?: string;
+};
+export type LoginPageProps = LoginPageConfig;
+export type LoginFormProps = {
+    loginAction: LoginAction;
+    captchaGenerateAction?: CaptchaAction<CaptchaChallenge>;
+    captchaConfig?: CaptchaConfig;
+    showRememberMe?: boolean;
+    showForgotPassword?: boolean;
+    showSignUp?: boolean;
+    forgotPasswordHref?: string;
+    signUpHref?: string;
+    onForgotPassword?: () => void;
+    onSignUp?: () => void;
+    onSuccess?: () => void;
+};
+export type LoginHeaderProps = {
+    logo?: React.ReactNode;
+    title?: string;
+    subtitle?: string;
+};
+export type LoginState = {
+    email: string;
+    password: string;
+    rememberMe: boolean;
+    isLoading: boolean;
+    error: string | null;
+    captchaId: string | null;
+    captchaAnswer: string;
+    isAuthenticated: boolean;
+    user: {
+        id: string;
+        email: string;
+    } | null;
+};
+export type LoginActions = {
+    setEmail: (email: string) => void;
+    setPassword: (password: string) => void;
+    setRememberMe: (value: boolean) => void;
+    setLoading: (value: boolean) => void;
+    setError: (error: string | null) => void;
+    setCaptchaId: (id: string | null) => void;
+    setCaptchaAnswer: (answer: string) => void;
+    setAuthenticated: (isAuthenticated: boolean, user?: {
+        id: string;
+        email: string;
+    } | null) => void;
+    reset: () => void;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/MagicLinkVerifyPage/components/MagicLinkVerifyPage.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from "react";
+import type { MagicLinkVerifyPageConfig } from "../types";
+export declare function MagicLinkVerifyPage({ token, verifyAction, onSuccess, onError, onBackToLogin, backToLoginHref, redirectDelay, className, texts, }: MagicLinkVerifyPageConfig): ReactElement;
+//# sourceMappingURL=MagicLinkVerifyPage.d.ts.map

package/dist/fe/components/MagicLinkVerifyPage/index.d.ts

@@ -0,0 +1,5 @@
+export { MagicLinkVerifyPage } from "./components/MagicLinkVerifyPage";
+export { useMagicLinkVerifyStore } from "./store";
+export { magicLinkVerifyPageTheme } from "./theme";
+export type { MagicLinkVerifyAction, MagicLinkVerifyError, MagicLinkVerifyPageConfig, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/MagicLinkVerifyPage/store.d.ts

@@ -0,0 +1,15 @@
+type MagicLinkVerifyStep = "verifying" | "success" | "error";
+type MagicLinkVerifyState = {
+    [key: string]: unknown;
+    step: MagicLinkVerifyStep;
+    message: string;
+};
+type MagicLinkVerifyMethods = {
+    [key: string]: unknown;
+    setStep: (step: MagicLinkVerifyStep) => void;
+    setMessage: (message: string) => void;
+    reset: () => void;
+};
+export declare const useMagicLinkVerifyStore: () => import("h-state").StoreType<MagicLinkVerifyState, MagicLinkVerifyMethods>;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/dist/fe/components/MagicLinkVerifyPage/theme.d.ts

@@ -0,0 +1,37 @@
+export declare const magicLinkVerifyPageTheme: {
+    container: {
+        base: string;
+    };
+    card: {
+        base: string;
+        background: string;
+        border: string;
+        shadow: string;
+        rounded: string;
+    };
+    content: {
+        wrapper: string;
+    };
+    states: {
+        verifying: {
+            spinner: string;
+            title: string;
+            subtitle: string;
+        };
+        success: {
+            iconWrapper: string;
+            icon: string;
+            title: string;
+            subtitle: string;
+            redirectText: string;
+        };
+        error: {
+            iconWrapper: string;
+            icon: string;
+            title: string;
+            subtitle: string;
+        };
+    };
+    backButton: string;
+};
+//# sourceMappingURL=theme.d.ts.map

package/dist/fe/components/MagicLinkVerifyPage/types.d.ts

@@ -0,0 +1,35 @@
+import type { BaseErrorResponse, LoginSuccess } from "../../../src/Client/ApiCaller/types";
+export type MagicLinkVerifyAction = {
+    start: (config: {
+        payload: {
+            token: string;
+        };
+        onAfterHandle?: (data: LoginSuccess) => void;
+        onErrorHandle?: (error: MagicLinkVerifyError, code?: number | null) => void;
+    }) => void;
+    state: {
+        isPending: boolean;
+        data: LoginSuccess | null;
+        error: MagicLinkVerifyError | null;
+    };
+};
+export type MagicLinkVerifyError = BaseErrorResponse;
+export interface MagicLinkVerifyPageConfig {
+    token: string | null;
+    verifyAction: MagicLinkVerifyAction;
+    onSuccess?: (data: LoginSuccess) => void;
+    onError?: () => void;
+    onBackToLogin?: () => void;
+    backToLoginHref?: string;
+    redirectDelay?: number;
+    className?: string;
+    texts?: {
+        verifyingTitle?: string;
+        verifyingSubtitle?: string;
+        successTitle?: string;
+        successSubtitle?: string;
+        errorTitle?: string;
+        backToLogin?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/fe/components/NucleusEntityShowcase.d.ts

@@ -0,0 +1,3 @@
+import type { NucleusEntityShowcaseProps } from "../types";
+export declare function NucleusEntityShowcase<T extends Record<string, unknown> = Record<string, unknown>>({ entity, apiActions, title, description, pageSize, searchable, searchFields: _searchFields, filterable, sortable, selectable, showAdd, showEdit, showDelete, showBulkAdd: _showBulkAdd, showBulkDelete, columnConfigs, fieldConfigs, excludeColumns, excludeFields, onRowClick, renderHeader, renderToolbar, className, }: NucleusEntityShowcaseProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=NucleusEntityShowcase.d.ts.map

package/dist/fe/components/NucleusTextInput/components/FloatingLabel.d.ts

@@ -0,0 +1,3 @@
+import type { FloatingLabelProps } from "../types";
+export declare function FloatingLabel({ label, isFloated, isFocused, hasError, isDisabled, hasLeftIcon, className, }: FloatingLabelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FloatingLabel.d.ts.map