nucleus-core-ts 0.8.0

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

@@ -0,0 +1,15 @@
+interface IconProps {
+    className?: string;
+}
+export declare function MailIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function LockIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function EyeIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function EyeOffIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function HashIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function PhoneIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function LinkIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function TextIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function CheckIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function AlertCircleIcon({ className }: IconProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=InputIcons.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { NucleusTextInputProps } from "../types";
+export declare function NucleusTextInput<T extends string = string>({ value, onChange, type, label, placeholder, helperText, errorMessage, disabled, readOnly, leftIcon, rightIcon, size, fullWidth, className, inputClassName, labelClassName, wrapperClassName, showTypewriterError, showTypeIcon, showValidationIcon, enableValidation, validateOnBlur, validateOnChange, validationConfig, customValidator, onValidationChange, unit, unitPosition, formatNumber, thousandSeparator, phoneFormat, isNewPassword, maxInputLength, confirmValue, onConfirmChange, showPasswordStrength, preventCopy, preventPaste, preventContextMenu, trimOnBlur, onFocus, onBlur, ...restProps }: NucleusTextInputProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=NucleusTextInput.d.ts.map

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

@@ -0,0 +1,15 @@
+interface PasswordStrengthIndicatorProps {
+    password: string;
+    className?: string;
+}
+type StrengthLevel = "weak" | "fair" | "good" | "strong";
+interface StrengthResult {
+    level: StrengthLevel;
+    score: number;
+    label: string;
+    color: string;
+}
+declare function calculateStrength(password: string): StrengthResult;
+export declare function PasswordStrengthIndicator({ password, className, }: PasswordStrengthIndicatorProps): import("react/jsx-runtime").JSX.Element | null;
+export { calculateStrength, type StrengthLevel, type StrengthResult };
+//# sourceMappingURL=PasswordStrengthIndicator.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { TypewriterTextProps } from "../types";
+export declare function TypewriterText({ text, className, onComplete, }: TypewriterTextProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=TypewriterText.d.ts.map

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

@@ -0,0 +1,11 @@
+export { FloatingLabel } from "./components/FloatingLabel";
+export { NucleusTextInput } from "./components/NucleusTextInput";
+export type { StrengthLevel, StrengthResult, } from "./components/PasswordStrengthIndicator";
+export { calculateStrength, PasswordStrengthIndicator, } from "./components/PasswordStrengthIndicator";
+export { TypewriterText } from "./components/TypewriterText";
+export type { NucleusTextInputTheme } from "./theme";
+export { extendNucleusTextInputTheme, nucleusTextInputTheme } from "./theme";
+export type { FloatingLabelProps, InputState, InputType, NucleusTextInputProps, PhoneFormat, TypewriterTextProps, ValidationConfig, ValidationResult, } from "./types";
+export { formatNumberWithSeparator, formatPhoneNumber, parseFormattedNumber, unformatNumber, unformatPhone, } from "./utils/format";
+export { defaultValidators, getAutoCompleteForType, getInputModeForType, validateWithConfig, } from "./utils/validation";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,108 @@
+export declare const nucleusTextInputTheme: {
+    readonly container: {
+        readonly base: "relative w-full";
+        readonly spacing: "mb-1";
+    };
+    readonly wrapper: {
+        readonly base: "relative flex items-center";
+        readonly border: {
+            readonly base: "border rounded-lg";
+            readonly width: "border";
+            readonly radius: "rounded-lg";
+        };
+        readonly padding: "px-4 py-3";
+        readonly transition: "transition-all duration-200 ease-out";
+        readonly states: {
+            readonly inactive: "border-gray-300 dark:border-gray-600";
+            readonly hover: "border-gray-400 dark:border-gray-500";
+            readonly focused: "border-blue-600 dark:border-blue-500";
+            readonly error: "border-red-500 dark:border-red-400";
+            readonly disabled: "border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-800/50";
+        };
+    };
+    readonly input: {
+        readonly base: "w-full bg-transparent outline-none";
+        readonly text: "text-base";
+        readonly color: "text-gray-900 dark:text-gray-100";
+        readonly placeholder: "placeholder:text-gray-400 dark:placeholder:text-gray-500";
+        readonly disabled: "text-gray-400 dark:text-gray-500 cursor-not-allowed";
+        readonly transition: "transition-colors duration-200";
+    };
+    readonly label: {
+        readonly base: "absolute pointer-events-none select-none";
+        readonly text: "text-base";
+        readonly transition: "transition-all duration-200 ease-out";
+        readonly states: {
+            readonly inactive: {
+                readonly position: "left-3 top-1/2 -translate-y-1/2";
+                readonly text: "text-base";
+                readonly color: "text-gray-500 dark:text-gray-400";
+                readonly background: "bg-transparent px-1";
+            };
+            readonly floated: {
+                readonly position: "left-3 -top-2.5 translate-y-0";
+                readonly text: "text-xs";
+                readonly color: "text-gray-600 dark:text-gray-300";
+                readonly background: "bg-white/50 dark:bg-gray-900/50 px-1";
+            };
+            readonly focused: {
+                readonly color: "text-blue-600 dark:text-blue-500";
+            };
+            readonly error: {
+                readonly color: "text-red-500 dark:text-red-400";
+            };
+            readonly disabled: {
+                readonly color: "text-gray-400 dark:text-gray-500";
+            };
+        };
+    };
+    readonly helperText: {
+        readonly base: "mt-1.5 ml-1";
+        readonly text: "text-xs";
+        readonly color: "text-gray-500 dark:text-gray-400";
+        readonly disabled: "text-gray-400 dark:text-gray-500";
+    };
+    readonly errorText: {
+        readonly base: "mt-1.5 ml-1";
+        readonly text: "text-xs";
+        readonly color: "text-red-500 dark:text-red-400";
+        readonly minHeight: "min-h-[1.25rem]";
+    };
+    readonly icon: {
+        readonly base: "flex-shrink-0";
+        readonly size: "w-5 h-5";
+        readonly color: "text-gray-400 dark:text-gray-500";
+        readonly spacing: {
+            readonly left: "mr-2";
+            readonly right: "ml-2";
+        };
+        readonly states: {
+            readonly focused: "text-blue-600 dark:text-blue-500";
+            readonly error: "text-red-500 dark:text-red-400";
+            readonly disabled: "text-gray-300 dark:text-gray-600";
+        };
+    };
+    readonly animation: {
+        readonly label: {
+            readonly duration: 0.35;
+            readonly ease: "power3.out";
+            readonly floatY: -24;
+            readonly floatScale: 0.75;
+        };
+        readonly typewriter: {
+            readonly charDelay: 0.03;
+            readonly ease: "none";
+        };
+        readonly border: {
+            readonly duration: 0.2;
+            readonly ease: "power2.out";
+        };
+    };
+};
+export type NucleusTextInputTheme = typeof nucleusTextInputTheme;
+export declare function extendNucleusTextInputTheme(overrides: DeepPartial<NucleusTextInputTheme>): NucleusTextInputTheme;
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,65 @@
+import type { InputHTMLAttributes, ReactNode } from "react";
+import type { PhoneFormat } from "../utils/format";
+import type { InputType, ValidationConfig, ValidationResult } from "../utils/validation";
+export type { PhoneFormat };
+export type InputState = "inactive" | "hover" | "focused" | "error" | "disabled";
+export type { InputType, ValidationConfig, ValidationResult };
+export interface NucleusTextInputProps<T extends string = string> extends Omit<InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "size" | "type"> {
+    value?: T;
+    onChange?: (value: T) => void;
+    type?: InputType;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    errorMessage?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+    size?: "sm" | "md" | "lg";
+    fullWidth?: boolean;
+    className?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+    wrapperClassName?: string;
+    showTypewriterError?: boolean;
+    showTypeIcon?: boolean;
+    showValidationIcon?: boolean;
+    enableValidation?: boolean;
+    validateOnBlur?: boolean;
+    validateOnChange?: boolean;
+    validationConfig?: ValidationConfig;
+    customValidator?: (value: string) => ValidationResult;
+    onValidationChange?: (result: ValidationResult) => void;
+    unit?: string;
+    unitPosition?: "prefix" | "suffix";
+    formatNumber?: boolean;
+    thousandSeparator?: string;
+    phoneFormat?: PhoneFormat;
+    isNewPassword?: boolean;
+    maxInputLength?: number;
+    confirmValue?: string;
+    onConfirmChange?: (value: string) => void;
+    showPasswordStrength?: boolean;
+    preventCopy?: boolean;
+    preventPaste?: boolean;
+    preventContextMenu?: boolean;
+    trimOnBlur?: boolean;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+}
+export interface FloatingLabelProps {
+    label: string;
+    isFloated: boolean;
+    isFocused: boolean;
+    hasError: boolean;
+    isDisabled: boolean;
+    hasLeftIcon?: boolean;
+    className?: string;
+}
+export interface TypewriterTextProps {
+    text: string;
+    className?: string;
+    onComplete?: () => void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/fe/components/NucleusTextInput/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/NucleusTextInput/utils/format.d.ts

@@ -0,0 +1,8 @@
+export declare function formatNumberWithSeparator(value: string, separator?: string): string;
+export declare function unformatNumber(value: string): string;
+export declare function parseFormattedNumber(value: string): number;
+export type PhoneFormat = "tr" | "us" | "eu";
+export declare function formatPhoneNumber(value: string, format?: PhoneFormat): string;
+export declare function unformatPhone(value: string): string;
+export declare function getPhoneFormatPattern(format: PhoneFormat): number[];
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1,23 @@
+export type InputType = "text" | "email" | "password" | "number" | "tel" | "url";
+export interface ValidationResult {
+    isValid: boolean;
+    errorMessage?: string;
+}
+export interface ValidationRule {
+    validate: (value: string) => boolean;
+    message: string;
+}
+export interface ValidationConfig {
+    required?: boolean;
+    requiredMessage?: string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    patternMessage?: string;
+    customRules?: ValidationRule[];
+}
+export declare const defaultValidators: Record<InputType, (value: string) => ValidationResult>;
+export declare function validateWithConfig(value: string, inputType: InputType, config?: ValidationConfig): ValidationResult;
+export declare function getInputModeForType(inputType: InputType): React.HTMLAttributes<HTMLInputElement>["inputMode"];
+export declare function getAutoCompleteForType(inputType: InputType, isNewPassword?: boolean): string;
+//# sourceMappingURL=validation.d.ts.map

package/dist/fe/components/ProfilePage/components/AddressCard.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from "react";
+import type { AddressCardProps } from "../types";
+export declare function AddressCard({ address, onEdit, onDelete, isUpdating, isDeleting, allowEdit, }: AddressCardProps): ReactElement;
+//# sourceMappingURL=AddressCard.d.ts.map

package/dist/fe/components/ProfilePage/components/PhoneCard.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from "react";
+import type { PhoneCardProps } from "../types";
+export declare function PhoneCard({ phone, onEdit, onDelete, isUpdating, isDeleting, allowEdit, }: PhoneCardProps): ReactElement;
+//# sourceMappingURL=PhoneCard.d.ts.map

package/dist/fe/components/ProfilePage/components/ProfileHeader.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from "react";
+import type { ProfileHeaderProps } from "../types";
+export declare function ProfileHeader({ user, profile, profilePicture, fileProxyBasePath, onUploadPicture, isUploading, }: ProfileHeaderProps): ReactElement;
+//# sourceMappingURL=ProfileHeader.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { ReactElement } from "react";
+import type { ProfilePageProps } from "../types";
+export declare function ProfilePage({ meAction, addProfileAction, updateProfileAction, addAddressAction, updateAddressAction, deleteAddressAction, addPhoneAction, updatePhoneAction, deletePhoneAction, uploadFileAction, updateFileAction, deleteFileAction, fileProxyBasePath, onProfileUpdated, onAddressAdded, onAddressUpdated, onAddressDeleted, onPhoneAdded, onPhoneUpdated, onPhoneDeleted, onFileUploaded, onFileUpdated, onFileDeleted, onProfilePictureChanged, showBackground, allowProfileEdit, allowAddressEdit, allowPhoneEdit, allowFileUpload, changePasswordHref, devicesHref, onChangePassword, onViewDevices, }: ProfilePageProps): ReactElement;
+//# sourceMappingURL=ProfilePage.d.ts.map

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

@@ -0,0 +1,10 @@
+export type { MeResponseData } from "../../../src/Client/ApiCaller/types";
+export { AddressCard } from "./components/AddressCard";
+export { PhoneCard } from "./components/PhoneCard";
+export { ProfileHeader } from "./components/ProfileHeader";
+export { ProfilePage } from "./components/ProfilePage";
+export { useProfileStore } from "./store";
+export type { ProfilePageTheme } from "./theme";
+export { extendProfilePageTheme, profilePageTheme } from "./theme";
+export type { AddressCardProps, AddressInfo, AddressSectionProps, FileInfo, PhoneCardProps, PhoneInfo, PhoneSectionProps, ProfileHeaderProps, ProfileInfo, ProfileInfoSectionProps, ProfilePageConfig, ProfilePageProps, ProfilePageVariant, ProfileState, UserInfo, } from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,37 @@
+import type { AddressInfo, FileInfo, PhoneInfo, ProfileInfo, RoleInfo, UserInfo } from "../types";
+type ProfileStoreState = {
+    user: UserInfo | null;
+    profile: ProfileInfo | null;
+    addresses: AddressInfo[];
+    phones: PhoneInfo[];
+    files: FileInfo[];
+    roles: RoleInfo[];
+    profilePicture: FileInfo | null;
+    isEditingProfile: boolean;
+};
+type OptimisticEntity<T> = Partial<T> & {
+    id: string;
+};
+type ProfileMethods = {
+    setUser: (user: UserInfo | null) => void;
+    setProfile: (profile: Partial<ProfileInfo> | null) => void;
+    setAddresses: (addresses: AddressInfo[]) => void;
+    setPhones: (phones: PhoneInfo[]) => void;
+    setFiles: (files: FileInfo[]) => void;
+    setRoles: (roles: RoleInfo[]) => void;
+    setProfilePicture: (file: FileInfo | null) => void;
+    setEditingProfile: (value: boolean) => void;
+    addAddress: (address: OptimisticEntity<AddressInfo>) => void;
+    updateAddress: (address: OptimisticEntity<AddressInfo>) => void;
+    removeAddress: (addressId: string) => void;
+    addPhone: (phone: OptimisticEntity<PhoneInfo>) => void;
+    updatePhone: (phone: OptimisticEntity<PhoneInfo>) => void;
+    removePhone: (phoneId: string) => void;
+    addFile: (file: FileInfo) => void;
+    updateFile: (file: FileInfo) => void;
+    removeFile: (fileId: string) => void;
+    reset: () => void;
+};
+export declare const useProfileStore: () => import("h-state").StoreType<ProfileStoreState, ProfileMethods>;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,101 @@
+export type ProfilePageTheme = {
+    container: {
+        base: string;
+        wrapper: string;
+    };
+    card: {
+        base: string;
+        padding: string;
+        background: string;
+        border: string;
+        shadow: string;
+        rounded: string;
+    };
+    header: {
+        container: string;
+        avatar: {
+            wrapper: string;
+            image: string;
+            placeholder: string;
+            uploadButton: string;
+        };
+        info: {
+            container: string;
+            name: string;
+            email: string;
+            meta: string;
+        };
+    };
+    section: {
+        container: string;
+        title: string;
+        titleWrapper: string;
+        addButton: string;
+        content: string;
+        empty: {
+            container: string;
+            icon: string;
+            text: string;
+        };
+    };
+    profileForm: {
+        container: string;
+        grid: string;
+        field: {
+            container: string;
+            label: string;
+            input: string;
+            error: string;
+        };
+        actions: string;
+    };
+    itemCard: {
+        base: string;
+        padding: string;
+        background: string;
+        border: string;
+        rounded: string;
+        hover: string;
+        header: {
+            container: string;
+            icon: string;
+            title: string;
+            subtitle: string;
+            actions: string;
+        };
+        details: {
+            container: string;
+            row: string;
+            label: string;
+            value: string;
+        };
+    };
+    modal: {
+        overlay: string;
+        container: string;
+        title: string;
+        form: string;
+        actions: string;
+    };
+    loading: {
+        container: string;
+        spinner: string;
+        text: string;
+    };
+    error: {
+        container: string;
+        text: string;
+    };
+    accountSettings: {
+        container: string;
+        item: string;
+        iconWrapper: string;
+        content: string;
+        title: string;
+        description: string;
+        arrow: string;
+    };
+};
+export declare const profilePageTheme: ProfilePageTheme;
+export declare function extendProfilePageTheme(overrides: Partial<ProfilePageTheme>): ProfilePageTheme;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,150 @@
+import type { BaseErrorResponse, DeleteResponse, EndpointAction, MeSuccessResponse, MutationResponse, SystemAddressEntity, SystemFileEntity, SystemPhoneEntity, SystemProfileEntity, SystemRoleEntity, SystemUserEntity } from "../../../..";
+export type ProfilePageVariant = "default" | "minimal" | "compact";
+export type UserInfo = SystemUserEntity;
+export type ProfileInfo = SystemProfileEntity;
+export type AddressInfo = SystemAddressEntity;
+export type PhoneInfo = SystemPhoneEntity;
+export type FileInfo = SystemFileEntity;
+export type RoleInfo = SystemRoleEntity;
+export type ProfilePageConfig<TProfile = ProfileInfo, TAddress = AddressInfo, TPhone = PhoneInfo, TFile = FileInfo> = {
+    variant?: ProfilePageVariant;
+    title?: string;
+    subtitle?: string;
+    meAction: EndpointAction<undefined, MeSuccessResponse, BaseErrorResponse>;
+    addProfileAction: EndpointAction<Partial<TProfile>, MutationResponse<TProfile>, BaseErrorResponse>;
+    updateProfileAction: EndpointAction<Partial<TProfile> & {
+        id: string;
+    }, MutationResponse<TProfile>, BaseErrorResponse>;
+    addAddressAction: EndpointAction<Partial<TAddress>, MutationResponse<TAddress>, BaseErrorResponse>;
+    updateAddressAction: EndpointAction<Partial<TAddress> & {
+        id: string;
+    }, MutationResponse<TAddress>, BaseErrorResponse>;
+    deleteAddressAction: EndpointAction<{
+        id: string;
+    }, DeleteResponse, BaseErrorResponse>;
+    addPhoneAction: EndpointAction<Partial<TPhone>, MutationResponse<TPhone>, BaseErrorResponse>;
+    updatePhoneAction: EndpointAction<Partial<TPhone> & {
+        id: string;
+    }, MutationResponse<TPhone>, BaseErrorResponse>;
+    deletePhoneAction: EndpointAction<{
+        id: string;
+    }, DeleteResponse, BaseErrorResponse>;
+    uploadFileAction?: {
+        start: (opts: {
+            payload: object;
+            onAfterHandle?: (response: MutationResponse<TFile>) => void;
+            onErrorHandle?: (error: BaseErrorResponse) => void;
+        }) => void;
+        state: {
+            isPending: boolean;
+        };
+    };
+    updateFileAction?: EndpointAction<Partial<TFile> & {
+        id: string;
+    }, MutationResponse<TFile>, BaseErrorResponse>;
+    deleteFileAction?: EndpointAction<{
+        id: string;
+    }, DeleteResponse, BaseErrorResponse>;
+    fileProxyBasePath?: string;
+    onProfileUpdated?: (profile: TProfile) => void;
+    onAddressAdded?: (address: TAddress) => void;
+    onAddressUpdated?: (address: TAddress) => void;
+    onAddressDeleted?: (addressId: string) => void;
+    onPhoneAdded?: (phone: TPhone) => void;
+    onPhoneUpdated?: (phone: TPhone) => void;
+    onPhoneDeleted?: (phoneId: string) => void;
+    onFileUploaded?: (file: TFile) => void;
+    onFileUpdated?: (file: TFile) => void;
+    onFileDeleted?: (fileId: string) => void;
+    onProfilePictureChanged?: (file: TFile) => void;
+    showBackground?: boolean;
+    allowProfileEdit?: boolean;
+    allowAddressEdit?: boolean;
+    allowPhoneEdit?: boolean;
+    allowFileUpload?: boolean;
+    changePasswordHref?: string;
+    devicesHref?: string;
+    onChangePassword?: () => void;
+    onViewDevices?: () => void;
+    className?: string;
+};
+export type ProfilePageProps<TProfile = ProfileInfo, TAddress = AddressInfo, TPhone = PhoneInfo, TFile = FileInfo> = ProfilePageConfig<TProfile, TAddress, TPhone, TFile>;
+export type ProfileHeaderProps = {
+    title?: string;
+    subtitle?: string;
+    user?: UserInfo;
+    profile?: ProfileInfo;
+    profilePicture?: FileInfo;
+    fileProxyBasePath?: string;
+    onUploadPicture?: () => void;
+    isUploading?: boolean;
+};
+export type ProfileInfoSectionProps = {
+    user?: UserInfo;
+    profile?: ProfileInfo;
+    isEditing: boolean;
+    onEdit: () => void;
+    onSave: (data: Partial<ProfileInfo>) => void;
+    onCancel: () => void;
+    isSaving: boolean;
+    allowEdit?: boolean;
+};
+export type AddressSectionProps = {
+    addresses: AddressInfo[];
+    userId: string;
+    onAdd: (address: Omit<AddressInfo, "id">) => void;
+    onUpdate: (address: AddressInfo) => void;
+    onDelete: (addressId: string) => void;
+    isAdding: boolean;
+    isUpdating: string | null;
+    isDeleting: string | null;
+    allowEdit?: boolean;
+};
+export type AddressCardProps = {
+    address: AddressInfo;
+    onEdit: (address: AddressInfo) => void;
+    onDelete: (addressId: string) => void;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    allowEdit?: boolean;
+};
+export type PhoneSectionProps = {
+    phones: PhoneInfo[];
+    userId: string;
+    onAdd: (phone: Omit<PhoneInfo, "id">) => void;
+    onUpdate: (phone: PhoneInfo) => void;
+    onDelete: (phoneId: string) => void;
+    isAdding: boolean;
+    isUpdating: string | null;
+    isDeleting: string | null;
+    allowEdit?: boolean;
+};
+export type PhoneCardProps = {
+    phone: PhoneInfo;
+    onEdit: (phone: PhoneInfo) => void;
+    onDelete: (phoneId: string) => void;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    allowEdit?: boolean;
+};
+export type ProfileState = {
+    user: UserInfo | null;
+    profile: ProfileInfo | null;
+    addresses: AddressInfo[];
+    phones: PhoneInfo[];
+    files: FileInfo[];
+    profilePicture: FileInfo | null;
+    isLoading: boolean;
+    error: string | null;
+    isEditingProfile: boolean;
+    isSavingProfile: boolean;
+    isAddingAddress: boolean;
+    updatingAddressId: string | null;
+    deletingAddressId: string | null;
+    isAddingPhone: boolean;
+    updatingPhoneId: string | null;
+    deletingPhoneId: string | null;
+    isUploadingFile: boolean;
+    deletingFileId: string | null;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { RangePickerProps } from "../types";
+export declare function RangePicker({ value: controlledValue, defaultValue, min, max, step, minRange, disabled, readOnly, size, variant, orientation, showTooltip, showLabels, showTicks, tickCount, debounceMs, formatValue, onChange, onChangeCommit, label, minLabel, maxLabel, ariaLabel, ariaLabelMin, ariaLabelMax, className, ...props }: RangePickerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RangePicker.d.ts.map

package/dist/fe/components/RangePicker/components/RangeThumb.d.ts

@@ -0,0 +1,3 @@
+import type { RangeThumbProps } from "../types";
+export declare const RangeThumb: import("react").ForwardRefExoticComponent<RangeThumbProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=RangeThumb.d.ts.map

package/dist/fe/components/RangePicker/components/RangeTooltip.d.ts

@@ -0,0 +1,3 @@
+import type { RangeTooltipProps } from "../types";
+export declare function RangeTooltip({ value, visible, size, formatValue, }: RangeTooltipProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RangeTooltip.d.ts.map

package/dist/fe/components/RangePicker/components/RangeTrack.d.ts

@@ -0,0 +1,3 @@
+import type { RangeTrackProps } from "../types";
+export declare const RangeTrack: import("react").ForwardRefExoticComponent<RangeTrackProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=RangeTrack.d.ts.map

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

@@ -0,0 +1,8 @@
+export { RangePicker } from "./components/RangePicker";
+export { RangeThumb } from "./components/RangeThumb";
+export { RangeTooltip } from "./components/RangeTooltip";
+export { RangeTrack } from "./components/RangeTrack";
+export type { RangePickerTheme } from "./theme";
+export { rangePickerTheme } from "./theme";
+export type { RangePickerOrientation, RangePickerProps, RangePickerSize, RangePickerVariant, RangeThumbProps, RangeTooltipProps, RangeTrackProps, RangeValue, } from "./types";
+//# sourceMappingURL=index.d.ts.map