@intlayer/design-system 6.1.6 → 7.0.0-canary.0

package/dist/types/components/Input/Checkbox.d.ts

@@ -0,0 +1,40 @@
+import { DetailedHTMLProps, FC, InputHTMLAttributes, ReactNode } from "react";
+import * as class_variance_authority_types11 from "class-variance-authority/types";
+import { VariantProps } from "class-variance-authority";
+
+//#region src/components/Input/Checkbox.d.ts
+declare const checkboxVariants: (props?: {
+  variant?: "default";
+  size?: "sm" | "md" | "lg";
+  color?: "text" | "primary" | "secondary" | "neutral" | "destructive" | "error" | "success" | "custom" | "light" | "dark";
+  validationStyleEnabled?: "disabled" | "enabled";
+} & class_variance_authority_types11.ClassProp) => string;
+declare enum CheckboxSize {
+  SM = "sm",
+  MD = "md",
+  LG = "lg",
+}
+declare enum CheckboxColor {
+  PRIMARY = "primary",
+  SECONDARY = "secondary",
+  DESTRUCTIVE = "destructive",
+  NEUTRAL = "neutral",
+  LIGHT = "light",
+  TEXT = "text",
+  DARK = "dark",
+  ERROR = "error",
+  SUCCESS = "success",
+  CUSTOM = "custom",
+}
+type CheckboxProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, 'size'> & {
+  name: string;
+  validationStyleEnabled?: boolean;
+  label?: ReactNode;
+} & Omit<VariantProps<typeof checkboxVariants>, 'validationStyleEnabled' | 'size' | 'color'> & {
+  size?: CheckboxSize | `${CheckboxSize}`;
+  color?: CheckboxColor | `${CheckboxColor}`;
+};
+declare const Checkbox: FC<CheckboxProps>;
+//#endregion
+export { Checkbox, CheckboxColor, CheckboxProps, CheckboxSize, checkboxVariants };
+//# sourceMappingURL=Checkbox.d.ts.map

package/dist/types/components/Input/Checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checkbox.d.ts","names":[],"sources":["../../../../src/components/Input/Checkbox.tsx"],"sourcesContent":[],"mappings":";;;;;cAQa,wBA8CY;;;EA9CZ,KAAA,CAAA,EAAA,MAAA,GAAA,SAsCX,GAAA,WAAA,GAAA,SAAA,GAAA,aAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,GAAA,OAAA,GAAA,MAAA;EAEU,sBAAY,CAAA,EAAA,UAAA,GAAA,SAAA;AAMxB,CAAA,GARE,gCAAA,CAAA,SAQuB,EAAA,GAAA,MAAA;AAab,aAnBA,YAAA;EAoB4B,EAAA,GAAA,IAAA;EAApB,EAAA,GAAA,IAAA;EAAuC,EAAA,GAAA,IAAA;;AAD/B,aAbhB,aAAA;EAmBF,OAAA,GAAA,SAAA;EAEc,SAAA,GAAA,WAAA;EAApB,WAAA,GAAA,aAAA;EADA,OAAA,GAAA,SAAA;EAIO,KAAA,GAAA,OAAA;EAAkB,IAAA,GAAA,MAAA;EACjB,IAAA,GAAA,MAAA;EAAmB,KAAA,GAAA,OAAA;EAAa,OAAA,GAAA,SAAA;EA0B/B,MAAA,GAAA,QAcZ;;KApDW,aAAA,GAAgB,KAC1B,kBAAkB,oBAAoB,mBAAmB;;;UAKjD;IACN,KACA,oBAAoB;SAGb,kBAAkB;UACjB,mBAAmB;;cA0BlB,UAAU,GAAG"}

package/dist/types/components/Input/Input.d.ts

@@ -0,0 +1,28 @@
+import { DetailedHTMLProps, FC, InputHTMLAttributes } from "react";
+import * as class_variance_authority_types12 from "class-variance-authority/types";
+import { VariantProps } from "class-variance-authority";
+
+//#region src/components/Input/Input.d.ts
+declare const inputVariants: (props?: {
+  variant?: "default" | "invisible";
+  size?: "md" | "lg";
+  validationStyleEnabled?: "disabled" | "enabled";
+} & class_variance_authority_types12.ClassProp) => string;
+declare enum InputVariant {
+  DEFAULT = "default",
+  INVISIBLE = "invisible",
+}
+declare enum InputSize {
+  MD = "md",
+  LG = "lg",
+}
+type InputProps = DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> & {
+  validationStyleEnabled?: boolean;
+} & Omit<VariantProps<typeof inputVariants>, 'validationStyleEnabled' | 'variant' | 'size'> & {
+  variant?: InputVariant;
+  size?: InputSize;
+};
+declare const Input: FC<InputProps>;
+//#endregion
+export { Input, InputProps, InputSize, InputVariant, inputVariants };
+//# sourceMappingURL=Input.d.ts.map

package/dist/types/components/Input/Input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input.d.ts","names":[],"sources":["../../../../src/components/Input/Input.tsx"],"sourcesContent":[],"mappings":";;;;;cAGa,qBA6BW;;;EA7BX,sBA2BX,CAAA,EAAA,UAAA,GAAA,SAAA;AAEF,CAAA,GAFE,gCAAA,CAAA,SAEsB,EAAA,GAAA,MAAA;AAKZ,aALA,YAAA;EAUA,OAAA,GAAA,SAAU;EACA,SAAA,GAAA,WAAA;;AACpB,aAPU,SAAA;EAKa,EAAA,GAAA,IAAA;EAMD,EAAA,GAAA,IAAA;;AADpB,KALQ,UAAA,GAAa,iBAKrB,CAJF,mBAIE,CAJkB,gBAIlB,CAAA,EAHF,gBAGE,CAAA,GAAA;EAIU,sBAAA,CAAA,EAAA,OAAA;CACH,GALP,IAKO,CAJP,YAIO,CAAA,OAJa,aAIb,CAAA,EAAA,wBAAA,GAAA,SAAA,GAAA,MAAA,CAAA,GAAA;EAAS,OAAA,CAAA,EADN,YACM;EAGP,IAAA,CAAA,EAHF,SAmBV;;cAhBY,OAAO,GAAG"}

package/dist/types/components/Input/InputPassword.d.ts

@@ -0,0 +1,9 @@
+import { InputProps } from "./Input.js";
+import { FC } from "react";
+
+//#region src/components/Input/InputPassword.d.ts
+type InputPasswordProps = Omit<InputProps, 'type'>;
+declare const InputPassword: FC<InputPasswordProps>;
+//#endregion
+export { InputPassword };
+//# sourceMappingURL=InputPassword.d.ts.map

package/dist/types/components/Input/InputPassword.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputPassword.d.ts","names":[],"sources":["../../../../src/components/Input/InputPassword.tsx"],"sourcesContent":[],"mappings":";;;;KAMK,kBAAA,GAAqB,KAAK;cAElB,eAAe,GAAG"}

package/dist/types/components/Input/SearchInput.d.ts

@@ -0,0 +1,11 @@
+import { InputProps } from "./Input.js";
+import * as react_jsx_runtime14 from "react/jsx-runtime";
+
+//#region src/components/Input/SearchInput.d.ts
+declare const SearchInput: ({
+  className,
+  ...props
+}: InputProps) => react_jsx_runtime14.JSX.Element;
+//#endregion
+export { SearchInput };
+//# sourceMappingURL=SearchInput.d.ts.map

package/dist/types/components/Input/SearchInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchInput.d.ts","names":[],"sources":["../../../../src/components/Input/SearchInput.tsx"],"sourcesContent":[],"mappings":";;;;cAIa;;;GAAwC,eAAU,mBAAA,CAAA,GAAA,CAAA"}

package/dist/types/components/Input/index.d.ts

@@ -0,0 +1,5 @@
+import { Checkbox, CheckboxColor, CheckboxProps, CheckboxSize, checkboxVariants } from "./Checkbox.js";
+import { Input, InputProps, InputSize, InputVariant, inputVariants } from "./Input.js";
+import { InputPassword } from "./InputPassword.js";
+import { SearchInput } from "./SearchInput.js";
+export { Checkbox, CheckboxColor, CheckboxProps, CheckboxSize, Input, InputPassword, InputProps, InputSize, InputVariant, SearchInput, checkboxVariants, inputVariants };

package/dist/types/components/KeyboardScreenAdapter/index.d.ts

@@ -0,0 +1,108 @@
+import { FC, HTMLAttributes, PropsWithChildren } from "react";
+
+//#region src/components/KeyboardScreenAdapter/index.d.ts
+
+/**
+ * KeyboardScreenAdapter Component
+ *
+ * A smart wrapper component that automatically adapts the viewport height
+ * when virtual keyboards appear on mobile devices. This prevents content
+ * from being hidden behind the keyboard and ensures optimal user experience
+ * across all devices and orientations.
+ *
+ * @component
+ * @example
+ * Basic usage:
+ * ```tsx
+ * <KeyboardScreenAdapter>
+ *   <div>Your app content here</div>
+ * </KeyboardScreenAdapter>
+ * ```
+ *
+ * @example
+ * With custom styling:
+ * ```tsx
+ * <KeyboardScreenAdapter className="bg-gray-100 p-4">
+ *   <form>
+ *     <input type="text" placeholder="Enter your name" />
+ *     <input type="email" placeholder="Enter your email" />
+ *     <button type="submit">Submit</button>
+ *   </form>
+ * </KeyboardScreenAdapter>
+ * ```
+ *
+ * @example
+ * Mobile-first responsive design:
+ * ```tsx
+ * <KeyboardScreenAdapter className="md:min-h-screen">
+ *   <div className="flex flex-col h-full">
+ *     <header>Navigation</header>
+ *     <main className="flex-1 overflow-auto">
+ *       <input type="search" placeholder="Search..." />
+ *       Content that needs keyboard adaptation
+ *     </main>
+ *   </div>
+ * </KeyboardScreenAdapter>
+ * ```
+ *
+ * Features:
+ * - Automatic viewport height detection and adjustment
+ * - Smooth transitions when keyboard shows/hides
+ * - Works with both iOS and Android virtual keyboards
+ * - Responsive design that adapts to device orientation changes
+ * - Maintains scroll behavior and overflow handling
+ * - Lightweight with minimal performance impact
+ * - Client-side only (Next.js compatible with 'use client')
+ *
+ * How it works:
+ * 1. Uses the useKeyboardDetector hook to monitor window height changes
+ * 2. Detects when virtual keyboard appears (window height decreases)
+ * 3. Automatically adjusts the container's max-height to fit visible area
+ * 4. Provides smooth transitions for better user experience
+ * 5. Restores original height when keyboard disappears
+ *
+ * Use cases:
+ * - Mobile web applications with forms
+ * - Chat interfaces and messaging apps
+ * - Search interfaces and input-heavy UIs
+ * - Progressive Web Apps (PWAs)
+ * - Any mobile-first application requiring keyboard interaction
+ *
+ * Browser compatibility:
+ * - iOS Safari (all versions)
+ * - Chrome Mobile (Android)
+ * - Samsung Internet
+ * - Firefox Mobile
+ * - Other mobile browsers with virtual keyboards
+ *
+ * Performance considerations:
+ * - Uses ResizeObserver for efficient window monitoring
+ * - Minimal re-renders through optimized state management
+ * - CSS transitions handled by GPU acceleration
+ * - No layout thrashing during keyboard transitions
+ *
+ * Accessibility:
+ * - Maintains focus management during transitions
+ * - Preserves scroll position and user context
+ * - Compatible with screen readers and assistive technologies
+ * - Supports keyboard navigation patterns
+ *
+ * @param props - Component props extending standard div attributes
+ * @param props.children - Content to render within the adaptive container
+ * @param props.className - Additional CSS classes for the container
+ * @param props.style - Inline styles (note: maxHeight may be overridden)
+ * @param props.id - Unique identifier for the container
+ * @param props.role - ARIA role for accessibility
+ * @param props.tabIndex - Tab index for focus management
+ * @param props.onScroll - Scroll event handler
+ * @param props.onTouchStart - Touch start event handler
+ * @param props.onTouchMove - Touch move event handler
+ * @param props.onTouchEnd - Touch end event handler
+ * @param props...rest - All other standard HTML div attributes
+ *
+ * @returns A responsive container that adapts to keyboard visibility
+ */
+declare const KeyboardScreenAdapter: FC<PropsWithChildren<HTMLAttributes<HTMLDivElement>>>;
+//#endregion
+export { KeyboardScreenAdapter };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/KeyboardScreenAdapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/KeyboardScreenAdapter/index.tsx"],"sourcesContent":[],"mappings":";;;;;;AA0GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,uBAAuB,GAClC,kBAAkB,eAAe"}

package/dist/types/components/Label/index.d.ts

@@ -0,0 +1,72 @@
+import { FC, LabelHTMLAttributes } from "react";
+
+//#region src/components/Label/index.d.ts
+
+/**
+ * Props for the Label component
+ */
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+  /**
+   * The ID of the form control this label is associated with.
+   * This creates the accessible relationship between the label and its control.
+   * @example "email-input"
+   * @example "password-field"
+   */
+  htmlFor?: string;
+  /**
+   * Whether the associated form control is required.
+   * Adds visual indicator and updates ARIA attributes.
+   * @default false
+   */
+  required?: boolean;
+  /**
+   * Whether the associated form control is disabled.
+   * Updates styling to indicate disabled state.
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * Additional CSS classes for custom styling
+   * @example "text-red-600 font-bold"
+   */
+  className?: string;
+}
+/**
+ * Label Component
+ *
+ * A form label component that provides accessible labeling for form controls.
+ * Establishes proper relationships between labels and their associated form elements
+ * with visual indicators for required and disabled states.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <Label htmlFor="email">Email Address</Label>
+ * <input id="email" type="email" />
+ *
+ * // Required field
+ * <Label htmlFor="password" required>Password</Label>
+ * <input id="password" type="password" required />
+ *
+ * // Disabled field
+ * <Label htmlFor="disabled-field" disabled>Disabled Field</Label>
+ * <input id="disabled-field" type="text" disabled />
+ *
+ * // With custom styling
+ * <Label htmlFor="custom" className="text-blue-600 font-semibold">
+ *   Custom Styled Label
+ * </Label>
+ * ```
+ *
+ * @component
+ * @accessibility
+ * - Uses semantic HTML <label> element
+ * - Properly associates with form controls via htmlFor/id relationship
+ * - Supports click-to-focus behavior automatically
+ * - Visual indicators for required and disabled states
+ * - Screen reader compatible with proper ARIA relationships
+ */
+declare const Label: FC<LabelProps>;
+//#endregion
+export { Label, LabelProps };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/Label/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/Label/index.tsx"],"sourcesContent":[],"mappings":";;;;;;AAMA;AAiEa,UAjEI,UAAA,SAAmB,mBAiEd,CAjEkC,gBAiElC,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAT,OAAO,GAAG"}

package/dist/types/components/Link/Link.d.ts

@@ -0,0 +1,220 @@
+import { AnchorHTMLAttributes, DetailedHTMLProps, FC } from "react";
+import * as class_variance_authority_types13 from "class-variance-authority/types";
+import { VariantProps } from "class-variance-authority";
+import { LocalesValues } from "@intlayer/types";
+
+//#region src/components/Link/Link.d.ts
+
+/**
+ * Visual style variants for Link component
+ *
+ * @enum {string}
+ */
+declare enum LinkVariant {
+  /** Default underlined link with hover effects */
+  DEFAULT = "default",
+  /** Link without visible underline or hover effects */
+  INVISIBLE_LINK = "invisible-link",
+  /** Button-styled link with solid background */
+  BUTTON = "button",
+  /** Button-styled link with outlined border */
+  BUTTON_OUTLINED = "button-outlined",
+  /** Link with subtle hover background effect */
+  HOVERABLE = "hoverable",
+}
+/**
+ * Color theme variants for Link component
+ *
+ * @enum {string}
+ */
+declare enum LinkColor {
+  /** Primary brand color */
+  PRIMARY = "primary",
+  /** Secondary brand color */
+  SECONDARY = "secondary",
+  /** Destructive/danger color for critical actions */
+  DESTRUCTIVE = "destructive",
+  /** Neutral/muted color for less prominent links */
+  NEUTRAL = "neutral",
+  /** Light color for dark backgrounds */
+  LIGHT = "light",
+  /** Dark color for light backgrounds */
+  DARK = "dark",
+  /** Default text color */
+  TEXT = "text",
+  /** Inverse text color for opposite backgrounds */
+  TEXT_INVERSE = "text-inverse",
+  /** Error/red color for error states */
+  ERROR = "error",
+  /** Success/green color for positive actions */
+  SUCCESS = "success",
+  /** Custom color - no default styling applied */
+  CUSTOM = "custom",
+}
+/**
+ * Underline style options for Link component
+ *
+ * @enum {string}
+ */
+declare enum LinkUnderlined {
+  /** Default underline behavior based on variant */
+  DEFAULT = "default",
+  /** Always show underline */
+  TRUE = "true",
+  /** Never show underline */
+  FALSE = "false",
+}
+/**
+ * Class variance authority configuration for Link component styling
+ * Defines the visual appearance based on variant, color, and underline options
+ */
+declare const linkVariants: (props?: {
+  variant?: "default" | "button" | "invisible-link" | "hoverable" | "button-outlined";
+  color?: "error" | "success" | "custom" | "text" | "primary" | "neutral" | "secondary" | "destructive" | "light" | "dark" | "text-inverse";
+  underlined?: boolean | LinkUnderlined.DEFAULT;
+} & class_variance_authority_types13.ClassProp) => string;
+/**
+ * Props interface for the Link component
+ *
+ * @interface LinkProps
+ * @extends {DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>}
+ * @extends {VariantProps<typeof linkVariants>}
+ */
+type LinkProps = DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> & VariantProps<typeof linkVariants> & {
+  /**
+   * Accessible label for screen readers (required)
+   * Provides context about what the link does or where it leads
+   * @example "Navigate to home page"
+   */
+  label: string;
+  /**
+   * Whether this link opens in a new tab/window
+   * When true, adds target="_blank" and security attributes
+   * Auto-detected for URLs starting with http/https when undefined
+   * @default undefined (auto-detect based on href)
+   */
+  isExternalLink?: boolean;
+  /**
+   * Whether this link represents the current page/active state
+   * Adds aria-current="page" for accessibility
+   * @default false
+   */
+  isActive?: boolean;
+  /**
+   * Locale for internationalized URLs
+   * When provided, URLs are automatically localized using Intlayer
+   * @example 'fr', 'es', 'en'
+   */
+  locale?: LocalesValues;
+};
+/**
+ * Utility function to determine if a link should be treated as external
+ *
+ * @param props - Link component props containing href and isExternalLink
+ * @returns {boolean} True if the link should open externally
+ *
+ * @example
+ * ```tsx
+ * checkIsExternalLink({ href: 'https://example.com' }) // true
+ * checkIsExternalLink({ href: '/internal-page' }) // false
+ * checkIsExternalLink({ href: '/page', isExternalLink: true }) // true
+ * ```
+ */
+declare const checkIsExternalLink: ({
+  href,
+  isExternalLink: isExternalLinkProp
+}: LinkProps) => boolean;
+/**
+ * Link Component
+ *
+ * A versatile link component that handles both internal and external navigation
+ * with comprehensive internationalization support and multiple visual variants.
+ *
+ * ## Key Features
+ * - **Multiple Variants**: Default, invisible, button, outlined button, and hoverable styles
+ * - **Color Themes**: Comprehensive color palette for different contexts and meanings
+ * - **External Link Detection**: Automatic detection and handling of external URLs
+ * - **Internationalization**: Built-in support for localized URLs via Intlayer
+ * - **Security**: Automatic security attributes for external links (noopener, noreferrer)
+ * - **Accessibility**: Full ARIA support with proper labels and current page indication
+ * - **Visual Feedback**: Hover effects, underline options, and active states
+ *
+ * ## Use Cases
+ * - Navigation within applications (internal links)
+ * - External links to other websites with security measures
+ * - Button-styled links for call-to-action scenarios
+ * - Subtle hoverable links for navigation menus
+ * - Multi-language website navigation with automatic URL localization
+ *
+ * ## Security Features
+ * External links automatically receive security attributes:
+ * - `rel="noopener noreferrer nofollow"` - Prevents security vulnerabilities
+ * - `target="_blank"` - Opens in new tab/window
+ * - External link icon indication for user clarity
+ *
+ * ## Internationalization
+ * When used with Intlayer, the component automatically:
+ * - Localizes internal URLs based on the current or specified locale
+ * - Sets appropriate `hrefLang` attributes for SEO
+ * - Maintains proper URL structure for multi-language sites
+ *
+ * @component
+ * @example
+ * ```tsx
+ * // Basic internal link
+ * <Link href="/about" label="Go to about page">
+ *   About Us
+ * </Link>
+ *
+ * // External link with auto-detection
+ * <Link href="https://example.com" label="Visit external site">
+ *   External Site
+ * </Link>
+ *
+ * // Button-styled link
+ * <Link
+ *   href="/signup"
+ *   variant={LinkVariant.BUTTON}
+ *   color={LinkColor.PRIMARY}
+ *   label="Sign up for account"
+ * >
+ *   Get Started
+ * </Link>
+ *
+ * // Localized link
+ * <Link
+ *   href="/products"
+ *   locale="fr"
+ *   label="Voir les produits"
+ * >
+ *   Produits
+ * </Link>
+ *
+ * // Active navigation link
+ * <Link
+ *   href="/dashboard"
+ *   isActive={true}
+ *   variant={LinkVariant.HOVERABLE}
+ *   label="Current page: Dashboard"
+ * >
+ *   Dashboard
+ * </Link>
+ * ```
+ *
+ * @param props - Link component props
+ * @param props.children - Content to display inside the link
+ * @param props.href - URL or path to navigate to
+ * @param props.label - Accessible label describing the link's purpose
+ * @param props.variant - Visual style variant
+ * @param props.color - Color theme for the link
+ * @param props.underlined - Underline visibility option
+ * @param props.isExternalLink - Override external link detection
+ * @param props.isActive - Whether this link represents the current page
+ * @param props.locale - Locale for URL internationalization
+ * @param props.className - Additional CSS classes
+ * @returns Accessible and internationalized link component
+ */
+declare const Link: FC<LinkProps>;
+//#endregion
+export { Link, LinkColor, LinkProps, LinkUnderlined, LinkVariant, checkIsExternalLink, linkVariants };
+//# sourceMappingURL=Link.d.ts.map

package/dist/types/components/Link/Link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Link.d.ts","names":[],"sources":["../../../../src/components/Link/Link.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;;AAYA;AAkBA;AA8BY,aAhDA,WAAA;EA6DC;EAmDD,OAAA,GAAA,SAAS;EACE;EAArB,cAAA,GAAA,gBAAA;EACA;EAFsB,MAAA,GAAA,QAAA;EAIF;EAApB,eAAA,GAAA,iBAAA;EA4BW;EAAa,SAAA,GAAA,WAAA;AAgB1B;;;;;AAwGA;aAtPY,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8BA,cAAA;;;;;;;;;;;;cAaC;;;yBA0CZ,cAAA,CAAA;IAAA,gCAAA,CAAA;;;;;;;;KASW,SAAA,GAAY,kBACtB,qBAAqB,oBACrB,qBAEA,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;WA4BT;;;;;;;;;;;;;;;cAgBA;;kBAAuB;GAGjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqGU,MAAM,GAAG"}

package/dist/types/components/Link/index.d.ts

@@ -0,0 +1,2 @@
+import { Link, LinkColor, LinkProps, LinkUnderlined, LinkVariant, checkIsExternalLink, linkVariants } from "./Link.js";
+export { Link, LinkColor, LinkProps, LinkUnderlined, LinkVariant, checkIsExternalLink, linkVariants };

package/dist/types/components/Loader/index.content.d.ts

@@ -0,0 +1,55 @@
+import * as _intlayer_types313 from "@intlayer/types";
+
+//#region src/components/Loader/index.content.d.ts
+declare const loaderContent: {
+  key: string;
+  content: {
+    label: _intlayer_types313.TypedNodeModel<_intlayer_types313.NodeType.Translation, {
+      en: string;
+      'en-GB': string;
+      fr: string;
+      es: string;
+      de: string;
+      ja: string;
+      ko: string;
+      zh: string;
+      it: string;
+      pt: string;
+      hi: string;
+      ar: string;
+      ru: string;
+      tr: string;
+      pl: string;
+      id: string;
+      vi: string;
+    }, {
+      nodeType: _intlayer_types313.NodeType.Translation | "translation";
+    } & {
+      translation: {
+        en: string;
+        'en-GB': string;
+        fr: string;
+        es: string;
+        de: string;
+        ja: string;
+        ko: string;
+        zh: string;
+        it: string;
+        pt: string;
+        hi: string;
+        ar: string;
+        ru: string;
+        tr: string;
+        pl: string;
+        id: string;
+        vi: string;
+      };
+    }>;
+  };
+  title: string;
+  description: string;
+  tags: string[];
+};
+//#endregion
+export { loaderContent as default, loaderContent };
+//# sourceMappingURL=index.content.d.ts.map

package/dist/types/components/Loader/index.content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.content.d.ts","names":[],"sources":["../../../../src/components/Loader/index.content.ts"],"sourcesContent":[],"mappings":";;;cAEa;;;IAAA,KAAA,mCA2BS,0CAAA"}