@intlayer/design-system 9.4.2 → 9.4.4

package/dist/types/components/IDE/shikiLanguages.d.ts

@@ -2,11 +2,11 @@
 /**
  * Grammar registrations, as default-exported by the `shiki/langs/*` modules.
  */
-type LanguageGrammar = typeof import('shiki/langs/typescript.mjs')['default'];
+export type LanguageGrammar = typeof import('shiki/langs/typescript.mjs')['default'];
 /**
  * Loads a single Shiki grammar (and its embedded dependencies).
  */
-type GrammarLoader = () => Promise<{
+export type GrammarLoader = () => Promise<{
   default: LanguageGrammar;
 }>;
 /**
@@ -16,44 +16,17 @@ type GrammarLoader = () => Promise<{
  * bundlers can statically analyse them and emit one lazily fetched chunk per
  * grammar instead of bundling every language up front.
  */
-declare const grammarLoaders: {
-  'angular-html': () => Promise<typeof import("shiki/langs/angular-html.mjs")>;
-  'angular-ts': () => Promise<typeof import("shiki/langs/angular-ts.mjs")>;
+export declare const grammarLoaders: {
   astro: () => Promise<typeof import("shiki/langs/astro.mjs")>;
   bash: () => Promise<typeof import("shiki/langs/bash.mjs")>;
-  c: () => Promise<typeof import("shiki/langs/c.mjs")>;
-  cpp: () => Promise<typeof import("shiki/langs/cpp.mjs")>;
-  csharp: () => Promise<typeof import("shiki/langs/csharp.mjs")>;
   css: () => Promise<typeof import("shiki/langs/css.mjs")>;
-  csv: () => Promise<typeof import("shiki/langs/csv.mjs")>;
-  dart: () => Promise<typeof import("shiki/langs/dart.mjs")>;
-  diff: () => Promise<typeof import("shiki/langs/diff.mjs")>;
-  docker: () => Promise<typeof import("shiki/langs/docker.mjs")>;
-  go: () => Promise<typeof import("shiki/langs/go.mjs")>;
-  graphql: () => Promise<typeof import("shiki/langs/graphql.mjs")>;
   html: () => Promise<typeof import("shiki/langs/html.mjs")>;
-  http: () => Promise<typeof import("shiki/langs/http.mjs")>;
-  ini: () => Promise<typeof import("shiki/langs/ini.mjs")>;
-  java: () => Promise<typeof import("shiki/langs/java.mjs")>;
   javascript: () => Promise<typeof import("shiki/langs/javascript.mjs")>;
   json: () => Promise<typeof import("shiki/langs/json.mjs")>;
   json5: () => Promise<typeof import("shiki/langs/json5.mjs")>;
-  kotlin: () => Promise<typeof import("shiki/langs/kotlin.mjs")>;
-  less: () => Promise<typeof import("shiki/langs/less.mjs")>;
-  lua: () => Promise<typeof import("shiki/langs/lua.mjs")>;
+  jsonc: () => Promise<typeof import("shiki/langs/jsonc.mjs")>;
   markdown: () => Promise<typeof import("shiki/langs/markdown.mjs")>;
-  nginx: () => Promise<typeof import("shiki/langs/nginx.mjs")>;
-  php: () => Promise<typeof import("shiki/langs/php.mjs")>;
-  powershell: () => Promise<typeof import("shiki/langs/powershell.mjs")>;
-  prisma: () => Promise<typeof import("shiki/langs/prisma.mjs")>;
-  python: () => Promise<typeof import("shiki/langs/python.mjs")>;
-  ruby: () => Promise<typeof import("shiki/langs/ruby.mjs")>;
-  rust: () => Promise<typeof import("shiki/langs/rust.mjs")>;
-  scss: () => Promise<typeof import("shiki/langs/scss.mjs")>;
-  sql: () => Promise<typeof import("shiki/langs/sql.mjs")>;
   svelte: () => Promise<typeof import("shiki/langs/svelte.mjs")>;
-  swift: () => Promise<typeof import("shiki/langs/swift.mjs")>;
-  toml: () => Promise<typeof import("shiki/langs/toml.mjs")>;
   tsx: () => Promise<typeof import("shiki/langs/tsx.mjs")>;
   typescript: () => Promise<typeof import("shiki/langs/typescript.mjs")>;
   vue: () => Promise<typeof import("shiki/langs/vue.mjs")>;
@@ -61,38 +34,28 @@ declare const grammarLoaders: {
   yaml: () => Promise<typeof import("shiki/langs/yaml.mjs")>;
 };
 /** Canonical Shiki language ids this package can highlight. */
-type ShikiLanguageId = keyof typeof grammarLoaders;
+export type ShikiLanguageId = keyof typeof grammarLoaders;
 /** Every canonical language id that ships with a grammar loader. */
-declare const shikiLanguageIds: ShikiLanguageId[];
+export declare const shikiLanguageIds: ShikiLanguageId[];
 /**
  * Code fence names that are rendered by another grammar, mapped to the
  * canonical id that actually owns the grammar.
  */
-declare const grammarAliases: {
-  'c#': "csharp";
-  'c++': "cpp";
+export declare const grammarAliases: {
   cjs: "javascript";
   console: "bash";
-  cs: "csharp";
   cts: "typescript";
   dockerfile: "docker";
-  golang: "go";
   gql: "graphql";
   htm: "html";
   js: "javascript";
   jsonc: "json5";
   jsx: "tsx";
-  kt: "kotlin";
   md: "markdown";
   mdx: "markdown";
   mjs: "javascript";
   mts: "typescript";
   postcss: "css";
-  ps1: "powershell";
-  pwsh: "powershell";
-  py: "python";
-  rb: "ruby";
-  rs: "rust";
   sh: "bash";
   shell: "bash";
   shellscript: "bash";
@@ -101,18 +64,18 @@ declare const grammarAliases: {
   zsh: "bash";
 };
 /** Code fence names accepted as aliases of a canonical language id. */
-type ShikiLanguageAlias = keyof typeof grammarAliases;
+export type ShikiLanguageAlias = keyof typeof grammarAliases;
 /**
  * Languages Shiki renders without any grammar. They are also used as the
  * fallback for languages this package does not ship a grammar for.
  */
-type PlainTextLanguage = 'plaintext' | 'text' | 'txt';
+export type PlainTextLanguage = 'plaintext' | 'text' | 'txt';
 /** Every language name accepted by the code block components. */
-type CodeLanguage = ShikiLanguageId | ShikiLanguageAlias | PlainTextLanguage;
+export type CodeLanguage = ShikiLanguageId | ShikiLanguageAlias | PlainTextLanguage;
 /**
  * A language name resolved to what Shiki actually needs to highlight it.
  */
-type ResolvedCodeLanguage = {
+export type ResolvedCodeLanguage = {
   /** Canonical language id to pass to `codeToHtml` / `codeToHast`. */
   id: ShikiLanguageId | PlainTextLanguage;
   /** Grammar loader, or `null` when the language needs no grammar. */
@@ -132,7 +95,6 @@ type ResolvedCodeLanguage = {
  * resolveCodeLanguage('toml'); // { id: 'toml', loadGrammar: fn }
  * resolveCodeLanguage('brainfuck'); // { id: 'plaintext', loadGrammar: null }
  */
-declare const resolveCodeLanguage: (language: CodeLanguage | string | undefined | null) => ResolvedCodeLanguage;
+export declare const resolveCodeLanguage: (language: CodeLanguage | string | undefined | null) => ResolvedCodeLanguage;
 //#endregion
-export { CodeLanguage, GrammarLoader, LanguageGrammar, PlainTextLanguage, ResolvedCodeLanguage, ShikiLanguageAlias, ShikiLanguageId, resolveCodeLanguage, shikiLanguageIds };
 //# sourceMappingURL=shikiLanguages.d.ts.map

package/dist/types/components/IDE/shikiLanguages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shikiLanguages.d.ts","names":[],"sources":["../../../../src/components/IDE/shikiLanguages.ts"],"mappings":";;;;KAGY;;;;KAMA,sBAAsB;EAAU,SAAS;;;;;;;;;cAS/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8CM,+BAA+B;;cAG9B,kBAER;;;;;cAMC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkCM,kCAAkC;;;;;KAMlC;;KAKA,eACR,kBACA,qBACA;;;;KAKQ;;EAEV,IAAI,kBAAkB;;EAEtB,aAAa;;;;;;;;;;;;;;;;cAiBF,sBAAmB,UACpB,6CACT"}
+{"version":3,"file":"shikiLanguages.d.ts","names":[],"sources":["../../../../src/components/IDE/shikiLanguages.ts"],"mappings":";;;;YAGY;;;;YAMA,sBAAsB;EAAU,SAAS;;;;;;;;;qBASxC;;;;;;;;;;;;;;;;;;YA8CD,+BAA+B;;qBAG9B,kBAER;;;;;qBAMQ;;;;;;;;;;;;;;;;;;;;;;;YAwBD,kCAAkC;;;;;YAMlC;;YAKA,eACR,kBACA,qBACA;;;;YAKQ;;EAEV,IAAI,kBAAkB;;EAEtB,aAAa;;;;;;;;;;;;;;;;qBAiBF,sBAAmB,UACpB,6CACT"}

package/dist/types/components/IDE/shikiThemes.d.ts

@@ -8,11 +8,12 @@
  * theme-agnostic: it can be produced once — at build time — and never has to be
  * recomputed in the browser when the resolved theme changes.
  */
-declare const SHIKI_THEMES: {
+export declare const SHIKI_THEMES: {
   readonly light: 'github-light';
   readonly dark: 'github-dark';
 };
-type ShikiThemes = typeof SHIKI_THEMES;
+export type ShikiThemes = typeof SHIKI_THEMES;
+/** Every theme id the fine-grained Shiki bundle can resolve. */
+export type ShikiThemeId = ShikiThemes[keyof ShikiThemes];
 //#endregion
-export { SHIKI_THEMES, ShikiThemes };
 //# sourceMappingURL=shikiThemes.d.ts.map

package/dist/types/components/IDE/shikiThemes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shikiThemes.d.ts","names":[],"sources":["../../../../src/components/IDE/shikiThemes.ts"],"mappings":";;;;;;;;;;cASa;WACX;WACA;;KAGU,qBAAqB"}
+{"version":3,"file":"shikiThemes.d.ts","names":[],"sources":["../../../../src/components/IDE/shikiThemes.ts"],"mappings":";;;;;;;;;;qBASa;WACX;WACA;;YAGU,qBAAqB;;YAGrB,eAAe,kBAAkB"}

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

@@ -73,7 +73,6 @@ type CopiedTextInformationProps = DetailedHTMLProps<React.HTMLAttributes<HTMLEle
  *
  * @returns A rendered information tag with icon and text content
  */
-declare const InformationTag: FC<CopiedTextInformationProps>;
+export declare const InformationTag: FC<CopiedTextInformationProps>;
 //#endregion
-export { InformationTag };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/InformationTag/index.tsx"],"mappings":";;;;;;KAOK,6BAA6B,kBAChC,MAAM,eAAe,cACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuEW,gBAAgB,GAAG"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/InformationTag/index.tsx"],"mappings":";;;;;;KAOK,6BAA6B,kBAChC,MAAM,eAAe,cACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuEW,gBAAgB,GAAG"}

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

@@ -1,15 +1,15 @@
 import { DetailedHTMLProps, FC, InputHTMLAttributes, ReactNode } from "react";
 import { VariantProps } from "class-variance-authority";
 //#region src/components/Input/Checkbox.d.ts
-declare const checkboxVariants: (props?: {
+export declare const checkboxVariants: (props?: {
   variant?: "default";
   size?: "lg" | "md" | "sm" | "xs";
   color?: "custom" | "dark" | "error" | "light" | "neutral" | "primary" | "secondary" | "success" | "text" | "text-inverse";
   validationStyleEnabled?: "disabled" | "enabled";
 } & import("class-variance-authority/types").ClassProp) => string;
-type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg';
-type CheckboxColor = 'primary' | 'secondary' | 'neutral' | 'light' | 'text' | 'text-inverse' | 'dark' | 'error' | 'success' | 'custom';
-type CheckboxProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, 'size'> & {
+export type CheckboxSize = 'xs' | 'sm' | 'md' | 'lg';
+export type CheckboxColor = 'primary' | 'secondary' | 'neutral' | 'light' | 'text' | 'text-inverse' | 'dark' | 'error' | 'success' | 'custom';
+export type CheckboxProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, 'size'> & {
   name: string;
   validationStyleEnabled?: boolean;
   label?: ReactNode;
@@ -18,7 +18,6 @@ type CheckboxProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement
   color?: CheckboxColor | `${CheckboxColor}`;
   labelClassName?: string;
 };
-declare const Checkbox: FC<CheckboxProps>;
+export 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

@@ -1 +1 @@
-{"version":3,"file":"Checkbox.d.ts","names":[],"sources":["../../../../src/components/Input/Checkbox.tsx"],"mappings":";;;cASa,mBAAgB;;;;;6CAkE5B;KAEW;KAEA;KAYA,gBAAgB,KAC1B,kBAAkB,oBAAoB,mBAAmB;EAGzD;EACA;EACA,QAAQ;IACN,KACA,oBAAoB;EAGpB,OAAO,kBAAkB;EACzB,QAAQ,mBAAmB;EAC3B;;cA6BS,UAAU,GAAG"}
+{"version":3,"file":"Checkbox.d.ts","names":[],"sources":["../../../../src/components/Input/Checkbox.tsx"],"mappings":";;;qBASa,mBAAgB;;;;;6CAkE5B;YAEW;YAEA;YAYA,gBAAgB,KAC1B,kBAAkB,oBAAoB,mBAAmB;EAGzD;EACA;EACA,QAAQ;IACN,KACA,oBAAoB;EAGpB,OAAO,kBAAkB;EACzB,QAAQ,mBAAmB;EAC3B;;qBA6BS,UAAU,GAAG"}

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

@@ -1,17 +1,16 @@
 import { DetailedHTMLProps, FC, InputHTMLAttributes } from "react";
 import { VariantProps } from "class-variance-authority";
 //#region src/components/Input/Input.d.ts
-declare const inputVariants: (props?: {
+export declare const inputVariants: (props?: {
   variant?: "default" | "invisible";
   size?: "lg" | "md" | "sm";
   validationStyleEnabled?: "disabled" | "enabled";
 } & import("class-variance-authority/types").ClassProp) => string;
-type InputVariant = 'default' | 'invisible';
-type InputSize = 'md' | 'lg';
-type InputProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, 'size'> & {
+export type InputVariant = 'default' | 'invisible';
+export type InputSize = 'md' | 'lg';
+export type InputProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, 'size'> & {
   validationStyleEnabled?: boolean;
 } & Omit<VariantProps<typeof inputVariants>, 'validationStyleEnabled'>;
-declare const Input: FC<InputProps>;
+export 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

@@ -1 +1 @@
-{"version":3,"file":"Input.d.ts","names":[],"sources":["../../../../src/components/Input/Input.tsx"],"mappings":";;;cAOa,gBAAa;;;;6CAiDzB;KAEW;KAEA;KAEA,aAAa,KACvB,kBAAkB,oBAAoB,mBAAmB;EAGzD;IACE,KAAK,oBAAoB;cAEhB,OAAO,GAAG"}
+{"version":3,"file":"Input.d.ts","names":[],"sources":["../../../../src/components/Input/Input.tsx"],"mappings":";;;qBAOa,gBAAa;;;;6CAiDzB;YAEW;YAEA;YAEA,aAAa,KACvB,kBAAkB,oBAAoB,mBAAmB;EAGzD;IACE,KAAK,oBAAoB;qBAEhB,OAAO,GAAG"}

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

@@ -2,7 +2,6 @@ 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>;
+export declare const InputPassword: FC<InputPasswordProps>;
 //#endregion
-export { InputPassword };
 //# sourceMappingURL=InputPassword.d.ts.map

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

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

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

@@ -2,13 +2,13 @@ import { ButtonProps } from "../Button/Button.js";
 import "../Button/index.js";
 import { ComponentProps, FC, InputHTMLAttributes, ReactNode, RefObject } from "react";
 //#region src/components/Input/OTPInput.d.ts
-type SlotProps = {
+export type SlotProps = {
   isActive: boolean;
   char: string | null;
   placeholderChar: string | null;
   hasFakeCaret: boolean;
 };
-type RenderProps = {
+export type RenderProps = {
   slots: SlotProps[];
   isFocused: boolean;
   isHovering: boolean;
@@ -27,14 +27,14 @@ type OTPInputBaseProps = OverrideProps<InputHTMLAttributes<HTMLInputElement>, {
   noScriptCSSFallback?: string | null;
 }>;
 type InputOTPRenderFn = (props: RenderProps) => ReactNode;
-type OTPInputProps = OTPInputBaseProps & ({
+export type OTPInputProps = OTPInputBaseProps & ({
   render: InputOTPRenderFn;
   children?: never;
 } | {
   render?: never;
   children: ReactNode;
 });
-declare const usePasswordManagerBadge: ({ containerRef, inputRef, pushPasswordManagerStrategy, isFocused }: {
+export declare const usePasswordManagerBadge: ({ containerRef, inputRef, pushPasswordManagerStrategy, isFocused }: {
   containerRef: RefObject<HTMLDivElement | null>;
   inputRef: RefObject<HTMLInputElement | null>;
   pushPasswordManagerStrategy: OTPInputProps['pushPasswordManagerStrategy'];
@@ -44,21 +44,20 @@ declare const usePasswordManagerBadge: ({ containerRef, inputRef, pushPasswordMa
   willPushPWMBadge: boolean;
   PWM_BADGE_SPACE_WIDTH: "40px";
 };
-declare const usePrevious: <T>(value: T) => T | undefined;
-declare const OTPInputContext: import("react").Context<RenderProps>;
-declare const OTPInput: FC<OTPInputProps>;
+export declare const usePrevious: <T>(value: T) => T | undefined;
+export declare const OTPInputContext: import("react").Context<RenderProps>;
+export declare const OTPInput: FC<OTPInputProps>;
 type InputOTPProps = Omit<ComponentProps<typeof OTPInput>, 'children'>;
-declare const inputSlotVariants: (props?: {
+export declare const inputSlotVariants: (props?: {
   size?: "lg" | "md" | "sm" | "xl";
 } & import("class-variance-authority/types").ClassProp) => string;
-declare const InputOTP: FC<InputOTPProps>;
-declare const InputOTPGroup: ({ className, ...props }: ComponentProps<'div'>) => import("react").JSX.Element;
+export declare const InputOTP: FC<InputOTPProps>;
+export declare const InputOTPGroup: ({ className, ...props }: ComponentProps<'div'>) => import("react").JSX.Element;
 type InputOTPSlotProps = Omit<ButtonProps, 'variant' | 'label'> & {
   index: number;
 };
-declare const InputOTPSlot: FC<InputOTPSlotProps>;
-declare const InputOTPSeparator: FC<ComponentProps<'div'>>;
-declare const InputIndicator: FC<ComponentProps<'div'>>;
+export declare const InputOTPSlot: FC<InputOTPSlotProps>;
+export declare const InputOTPSeparator: FC<ComponentProps<'div'>>;
+export declare const InputIndicator: FC<ComponentProps<'div'>>;
 //#endregion
-export { InputIndicator, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, OTPInput, OTPInputContext, OTPInputProps, RenderProps, SlotProps, inputSlotVariants, usePasswordManagerBadge, usePrevious };
 //# sourceMappingURL=OTPInput.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"OTPInput.d.ts","names":[],"sources":["../../../../src/components/Input/OTPInput.tsx"],"mappings":";;;;KAsFY;EACV;EACA;EACA;EACA;;KAGU;EACV,OAAO;EACP;EACA;EACA,eAAe;;KAGZ,cAAc,GAAG,KAAK,KAAK,SAAS,KAAK;KAEzC,oBAAoB,cACvB,oBAAoB;EAElB;EACA,YAAY;EAEZ;EAEA,iBAAiB;EACjB,sBAAsB;EACtB;EACA,oBAAoB;EAEpB;EAEA;;KAIC,oBAAoB,OAAO,gBAAgB;KAEpC,gBAAgB;EAGpB,QAAQ;EACR;;EAGA;EACA,UAAU;;cAML,4BAAuB,cAAA,UAAA,6BAAA;EAMlC,cAAc,UAAU;EACxB,UAAU,UAAU;EACpB,6BAA6B;EAC7B;;;;;;cA6GW,cAAe,GAAC,OAAU,MAAI;cAU9B,iCAAe,QAAA;cAIf,UAAU,GAAG;KAshBrB,gBAAgB,KAAK,sBAAsB;cAEnC,oBAAiB;;6CAY5B;cAEW,UAAU,GAAG;cAeb,kBAAa,cAAA,SAGvB,0CAAqB,IAAA;KAMnB,oBAAoB,KAAK;EAC5B;;cAGW,cAAc,GAAG;cA8CjB,mBAAmB,GAAG;cAUtB,gBAAgB,GAAG"}
+{"version":3,"file":"OTPInput.d.ts","names":[],"sources":["../../../../src/components/Input/OTPInput.tsx"],"mappings":";;;;YAsFY;EACV;EACA;EACA;EACA;;YAGU;EACV,OAAO;EACP;EACA;EACA,eAAe;;KAGZ,cAAc,GAAG,KAAK,KAAK,SAAS,KAAK;KAEzC,oBAAoB,cACvB,oBAAoB;EAElB;EACA,YAAY;EAEZ;EAEA,iBAAiB;EACjB,sBAAsB;EACtB;EACA,oBAAoB;EAEpB;EAEA;;KAIC,oBAAoB,OAAO,gBAAgB;YAEpC,gBAAgB;EAGpB,QAAQ;EACR;;EAGA;EACA,UAAU;;qBAML,4BAAuB,cAAA,UAAA,6BAAA;EAMlC,cAAc,UAAU;EACxB,UAAU,UAAU;EACpB,6BAA6B;EAC7B;;;;;;qBA6GW,cAAe,GAAC,OAAU,MAAI;qBAU9B,iCAAe,QAAA;qBAIf,UAAU,GAAG;KAshBrB,gBAAgB,KAAK,sBAAsB;qBAEnC,oBAAiB;;6CAY5B;qBAEW,UAAU,GAAG;qBAeb,kBAAa,cAAA,SAGvB,0CAAqB,IAAA;KAMnB,oBAAoB,KAAK;EAC5B;;qBAGW,cAAc,GAAG;qBA8CjB,mBAAmB,GAAG;qBAUtB,gBAAgB,GAAG"}

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

@@ -1,15 +1,15 @@
 import { DetailedHTMLProps, FC, InputHTMLAttributes, ReactNode } from "react";
 import { VariantProps } from "class-variance-authority";
 //#region src/components/Input/Radio.d.ts
-declare const radioVariants: (props?: {
+export declare const radioVariants: (props?: {
   variant?: "default";
   size?: "lg" | "md" | "sm" | "xs";
   color?: "custom" | "dark" | "error" | "light" | "neutral" | "primary" | "secondary" | "success" | "text" | "text-inverse";
   validationStyleEnabled?: "disabled" | "enabled";
 } & import("class-variance-authority/types").ClassProp) => string;
-type RadioSize = 'xs' | 'sm' | 'md' | 'lg';
-type RadioColor = 'primary' | 'secondary' | 'neutral' | 'light' | 'text' | 'text-inverse' | 'dark' | 'error' | 'success' | 'custom';
-type RadioProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, 'size' | 'type'> & {
+export type RadioSize = 'xs' | 'sm' | 'md' | 'lg';
+export type RadioColor = 'primary' | 'secondary' | 'neutral' | 'light' | 'text' | 'text-inverse' | 'dark' | 'error' | 'success' | 'custom';
+export type RadioProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, 'size' | 'type'> & {
   name: string;
   validationStyleEnabled?: boolean;
   label?: ReactNode;
@@ -18,7 +18,6 @@ type RadioProps = Omit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>,
   color?: RadioColor | `${RadioColor}`;
   labelClassName?: string;
 };
-declare const Radio: FC<RadioProps>;
+export declare const Radio: FC<RadioProps>;
 //#endregion
-export { Radio, RadioColor, RadioProps, RadioSize, radioVariants };
 //# sourceMappingURL=Radio.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Radio.d.ts","names":[],"sources":["../../../../src/components/Input/Radio.tsx"],"mappings":";;;cASa,gBAAa;;;;;6CAiEzB;KAEW;KAEA;KAYA,aAAa,KACvB,kBAAkB,oBAAoB,mBAAmB;EAGzD;EACA;EACA,QAAQ;IACN,KACA,oBAAoB;EAGpB,OAAO,eAAe;EACtB,QAAQ,gBAAgB;EACxB;;cA8BS,OAAO,GAAG"}
+{"version":3,"file":"Radio.d.ts","names":[],"sources":["../../../../src/components/Input/Radio.tsx"],"mappings":";;;qBASa,gBAAa;;;;;6CAiEzB;YAEW;YAEA;YAYA,aAAa,KACvB,kBAAkB,oBAAoB,mBAAmB;EAGzD;EACA;EACA,QAAQ;IACN,KACA,oBAAoB;EAGpB,OAAO,eAAe;EACtB,QAAQ,gBAAgB;EACxB;;qBA8BS,OAAO,GAAG"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"SearchInput.d.ts","names":[],"sources":["../../../../src/components/Input/SearchInput.tsx"],"mappings":";;cAIa,gBAAW,cAAA,SAA6B,+BAAU,IAAA"}
+{"version":3,"file":"SearchInput.d.ts","names":[],"sources":["../../../../src/components/Input/SearchInput.tsx"],"mappings":";;qBAIa,gBAAW,cAAA,SAA6B,+BAAU,IAAA"}

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

@@ -100,7 +100,6 @@ import { FC, HTMLAttributes, PropsWithChildren } from "react";
  *
  * @returns A responsive container that adapts to keyboard visibility
  */
-declare const KeyboardScreenAdapter: FC<PropsWithChildren<HTMLAttributes<HTMLDivElement>>>;
+export declare const KeyboardScreenAdapter: FC<PropsWithChildren<HTMLAttributes<HTMLDivElement>>>;
 //#endregion
-export { KeyboardScreenAdapter };
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -3,14 +3,14 @@ import { FC } from "react";
 /**
  * Enum for available keyboard keys
  */
-type KeyList = 'Ctrl' | 'Alt' | 'Shift' | 'Meta' | 'F' | 'K' | 'L' | 'P' | 'S' | 'A' | 'B' | 'C' | 'D' | 'E' | 'G' | 'H' | 'I' | 'J' | 'M' | 'N' | 'O' | 'Q' | 'R' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | 'Enter' | 'Escape' | 'Backspace' | 'Tab' | 'Space' | 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight';
+export type KeyList = 'Ctrl' | 'Alt' | 'Shift' | 'Meta' | 'F' | 'K' | 'L' | 'P' | 'S' | 'A' | 'B' | 'C' | 'D' | 'E' | 'G' | 'H' | 'I' | 'J' | 'M' | 'N' | 'O' | 'Q' | 'R' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | 'Enter' | 'Escape' | 'Backspace' | 'Tab' | 'Space' | 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight';
 /**
  * Type-safe keyboard shortcut combinations
  * Note: Using string type to avoid union type complexity issues
  * Expected format: "Key + Key" (e.g., "⌘ + F", "Ctrl + Shift + K")
  */
-type KeyboardShortcutType = string;
-type KeyboardShortcutProps = {
+export type KeyboardShortcutType = string;
+export type KeyboardShortcutProps = {
   /** The keyboard shortcut combination (e.g., "⌘ + F" or "Ctrl + K") */
   shortcut: KeyboardShortcutType;
   /** Callback function triggered when the shortcut is pressed */
@@ -38,7 +38,6 @@ type KeyboardShortcutProps = {
  * />
  * ```
  */
-declare const KeyboardShortcut: FC<KeyboardShortcutProps>;
+export declare const KeyboardShortcut: FC<KeyboardShortcutProps>;
 //#endregion
-export { KeyList, KeyboardShortcut, KeyboardShortcutProps, KeyboardShortcutType };
 //# sourceMappingURL=KeyboardShortcut.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"KeyboardShortcut.d.ts","names":[],"sources":["../../../../src/components/KeyboardShortcut/KeyboardShortcut.tsx"],"mappings":";;;;;KASY;;;;;;KA8CA;KAEA;;EAEV,UAAU;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;cAmIW,kBAAkB,GAAG"}
+{"version":3,"file":"KeyboardShortcut.d.ts","names":[],"sources":["../../../../src/components/KeyboardShortcut/KeyboardShortcut.tsx"],"mappings":";;;;;YASY;;;;;;YA8CA;YAEA;;EAEV,UAAU;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;qBAmIW,kBAAkB,GAAG"}

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

@@ -3,7 +3,7 @@ import { FC, LabelHTMLAttributes } from "react";
 /**
  * Props for the Label component
  */
-interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+export 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.
@@ -64,7 +64,6 @@ interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
  * - Visual indicators for required and disabled states
  * - Screen reader compatible with proper ARIA relationships
  */
-declare const Label: FC<LabelProps>;
+export declare const Label: FC<LabelProps>;
 //#endregion
-export { Label, LabelProps };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/Label/index.tsx"],"mappings":";;;;;UAMiB,mBAAmB,oBAAoB;;;;;;;EAOtD;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCW,OAAO,GAAG"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/Label/index.tsx"],"mappings":";;;;;iBAMiB,mBAAmB,oBAAoB;;;;;;;EAOtD;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsCW,OAAO,GAAG"}

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

@@ -1,6 +1,5 @@
 import { FC, PropsWithChildren } from "react";
 //#region src/components/LanguageBackground/LanguageBackground.d.ts
-declare const LanguageBackground: FC<PropsWithChildren>;
+export declare const LanguageBackground: FC<PropsWithChildren>;
 //#endregion
-export { LanguageBackground };
 //# sourceMappingURL=LanguageBackground.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"LanguageBackground.d.ts","names":[],"sources":["../../../../src/components/LanguageBackground/LanguageBackground.tsx"],"mappings":";;cASa,oBAAoB,GAAG"}
+{"version":3,"file":"LanguageBackground.d.ts","names":[],"sources":["../../../../src/components/LanguageBackground/LanguageBackground.tsx"],"mappings":";;qBASa,oBAAoB,GAAG"}

package/dist/types/components/LanguageBackground/LanguageSection.d.ts

@@ -1,10 +1,9 @@
 import { FC, HTMLAttributes } from "react";
 //#region src/components/LanguageBackground/LanguageSection.d.ts
-declare const LocalCardList: FC<{
+export declare const LocalCardList: FC<{
   localeList: string[];
   className?: string;
 }>;
-declare const LanguageSection: FC<HTMLAttributes<HTMLElement>>;
+export declare const LanguageSection: FC<HTMLAttributes<HTMLElement>>;
 //#endregion
-export { LanguageSection, LocalCardList };
 //# sourceMappingURL=LanguageSection.d.ts.map

package/dist/types/components/LanguageBackground/LanguageSection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LanguageSection.d.ts","names":[],"sources":["../../../../src/components/LanguageBackground/LanguageSection.tsx"],"mappings":";;cAsDa,eAAe;EAC1B;EACA;;cAyBW,iBAAiB,GAAG,eAAe"}
+{"version":3,"file":"LanguageSection.d.ts","names":[],"sources":["../../../../src/components/LanguageBackground/LanguageSection.tsx"],"mappings":";;qBAsDa,eAAe;EAC1B;EACA;;qBAyBW,iBAAiB,GAAG,eAAe"}

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

@@ -2,31 +2,30 @@ import { AnchorHTMLAttributes, DetailedHTMLProps, FC, ReactNode } from "react";
 import { VariantProps } from "class-variance-authority";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/components/Link/Link.d.ts
-type LinkVariant = 'default' | 'invisible-link' | 'button' | 'button-outlined' | 'hoverable';
+export type LinkVariant = 'default' | 'invisible-link' | 'button' | 'button-outlined' | 'hoverable';
 /**
  * Color theme variants for Link component
  */
-type LinkColor = 'primary' | 'secondary' | 'neutral' | 'light' | 'dark' | 'text' | 'text-inverse' | 'error' | 'success' | 'custom';
-type LinkRoundedSize = 'none' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | 'full';
-type LinkSize = 'sm' | 'md' | 'lg' | 'xl' | 'custom';
-type LinkUnderlined = 'default' | 'true' | 'false';
-declare const linkVariants: (props?: {
+export type LinkColor = 'primary' | 'secondary' | 'neutral' | 'light' | 'dark' | 'text' | 'text-inverse' | 'error' | 'success' | 'custom';
+export type LinkRoundedSize = 'none' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | 'full';
+export type LinkSize = 'sm' | 'md' | 'lg' | 'xl' | 'custom';
+export type LinkUnderlined = 'default' | 'true' | 'false';
+export declare const linkVariants: (props?: {
   variant?: "button" | "button-outlined" | "default" | "hoverable" | "invisible-link";
   roundedSize?: "2xl" | "3xl" | "full" | "lg" | "md" | "none" | "sm" | "xl";
   color?: "custom" | "dark" | "error" | "light" | "neutral" | "primary" | "secondary" | "success" | "text" | "text-inverse";
   size?: "custom" | "lg" | "md" | "sm" | "xl";
   underlined?: "default" | boolean;
 } & import("class-variance-authority/types").ClassProp) => string;
-type LinkProps = DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> & VariantProps<typeof linkVariants> & {
+export type LinkProps = DetailedHTMLProps<AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> & VariantProps<typeof linkVariants> & {
   label: string;
   isExternalLink?: boolean;
   isPageSection?: boolean;
   isActive?: boolean;
   locale?: LocalesValues;
 };
-declare const checkIsExternalLink: ({ href, isExternalLink: isExternalLinkProp }: Pick<LinkProps, 'href' | 'isExternalLink'>, url?: string) => boolean;
-declare const isTextChildren: (children: ReactNode) => boolean;
-declare const Link: FC<LinkProps>;
+export declare const checkIsExternalLink: ({ href, isExternalLink: isExternalLinkProp }: Pick<LinkProps, 'href' | 'isExternalLink'>, url?: string) => boolean;
+export declare const isTextChildren: (children: ReactNode) => boolean;
+export declare const Link: FC<LinkProps>;
 //#endregion
-export { Link, LinkColor, LinkProps, LinkRoundedSize, LinkSize, LinkUnderlined, LinkVariant, checkIsExternalLink, isTextChildren, linkVariants };
 //# sourceMappingURL=Link.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Link.d.ts","names":[],"sources":["../../../../src/components/Link/Link.tsx"],"mappings":";;;;KAaY;;;;KAUA;KAYA;KAUA;KAEA;cAEC,eAAY;;;;;;6CA0JxB;KAEW,YAAY,kBACtB,qBAAqB,oBACrB,qBAEA,oBAAoB;EAClB;EACA;EACA;EACA;EACA,SAAS;;cAGA,wBAAmB,MAAA,gBAAA,sBAI3B,KAAK,uCAAqC;cAyClC,iBAAc,UAAc;cAe5B,MAAM,GAAG"}
+{"version":3,"file":"Link.d.ts","names":[],"sources":["../../../../src/components/Link/Link.tsx"],"mappings":";;;;YAaY;;;;YAUA;YAYA;YAUA;YAEA;qBAEC,eAAY;;;;;;6CA0JxB;YAEW,YAAY,kBACtB,qBAAqB,oBACrB,qBAEA,oBAAoB;EAClB;EACA;EACA;EACA;EACA,SAAS;;qBAGA,wBAAmB,MAAA,gBAAA,sBAI3B,KAAK,uCAAqC;qBAyClC,iBAAc,UAAc;qBAe5B,MAAM,GAAG"}

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

@@ -1,5 +1,5 @@
 //#region src/components/Loader/index.content.d.ts
-declare const loaderContent: {
+export declare const loaderContent: {
   key: string;
   content: {
     label: import("@intlayer/core/transpiler").TranslationContent<unknown, {
@@ -28,5 +28,5 @@ declare const loaderContent: {
   tags: string[];
 };
 //#endregion
-export { loaderContent as default, loaderContent };
+export { loaderContent as default };
 //# sourceMappingURL=index.content.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.content.d.ts","names":[],"sources":["../../../../src/components/Loader/index.content.ts"],"mappings":";cAEa;;;IAGT,2CAAK"}
+{"version":3,"file":"index.content.d.ts","names":[],"sources":["../../../../src/components/Loader/index.content.ts"],"mappings":";qBAEa;;;IAGT,2CAAK"}

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

@@ -3,7 +3,7 @@ import { FC, HTMLAttributes } from "react";
 /**
  * Props for the Loader component
  */
-type LoaderProps = HTMLAttributes<HTMLDivElement> & {
+export type LoaderProps = HTMLAttributes<HTMLDivElement> & {
   /** Controls whether the loading spinner is displayed. Defaults to true when undefined */
   isLoading?: boolean;
   /** Controls whether the children are kept when loading is false. Defaults to false */
@@ -96,7 +96,6 @@ type LoaderProps = HTMLAttributes<HTMLDivElement> & {
  *
  * @returns A loading spinner when isLoading is true, otherwise renders children
  */
-declare const Loader: FC<LoaderProps>;
+export declare const Loader: FC<LoaderProps>;
 //#endregion
-export { Loader, LoaderProps };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/Loader/index.tsx"],"mappings":";;;;;KAOY,cAAc,eAAe;;EAEvC;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0FW,QAAQ,GAAG"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/components/Loader/index.tsx"],"mappings":";;;;;YAOY,cAAc,eAAe;;EAEvC;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0FW,QAAQ,GAAG"}

package/dist/types/components/Loader/spinner.d.ts

@@ -59,7 +59,6 @@ type SpinnerProps = SVGProps<SVGSVGElement> & {
  *
  * @returns An animated SVG spinner element
  */
-declare const Spinner: ({ className, strokeWidth }: SpinnerProps) => import("react").JSX.Element;
+export declare const Spinner: ({ className, strokeWidth }: SpinnerProps) => import("react").JSX.Element;
 //#endregion
-export { Spinner };
 //# sourceMappingURL=spinner.d.ts.map

package/dist/types/components/Loader/spinner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spinner.d.ts","names":[],"sources":["../../../../src/components/Loader/spinner.tsx"],"mappings":";;;;;KAMK,eAAe,SAAS;;EAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuDW,YAAO,WAAA,eAAoC,iCAAY,IAAA"}
+{"version":3,"file":"spinner.d.ts","names":[],"sources":["../../../../src/components/Loader/spinner.tsx"],"mappings":";;;;;KAMK,eAAe,SAAS;;EAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuDW,YAAO,WAAA,eAAoC,iCAAY,IAAA"}

package/dist/types/components/LocaleSwitcherContentDropDown/LocaleSwitcherContent.d.ts

@@ -1,11 +1,10 @@
 import { PanelProps } from "../DropDown/index.js";
 import { FC } from "react";
 //#region src/components/LocaleSwitcherContentDropDown/LocaleSwitcherContent.d.ts
-type LocaleSwitcherContentProps = {
+export type LocaleSwitcherContentProps = {
   panelProps?: Omit<PanelProps, 'identifier'>;
   isMultilingual?: boolean;
 };
-declare const LocaleSwitcherContent: FC<LocaleSwitcherContentProps>;
+export declare const LocaleSwitcherContent: FC<LocaleSwitcherContentProps>;
 //#endregion
-export { LocaleSwitcherContent, LocaleSwitcherContentProps };
 //# sourceMappingURL=LocaleSwitcherContent.d.ts.map