@descope/flow-components 3.1.1 → 3.1.3

package/dist/index.d.ts

@@ -77,6 +77,7 @@ declare const HoneypotClass: ComponentClass;
 type KebabCase<S extends string> = S extends `${infer First}${infer Rest}` ? Rest extends Uncapitalize<Rest> ? `${Uncapitalize<First>}${KebabCase<Rest>}` : `${Uncapitalize<First>}-${KebabCase<Rest>}` : S;
 type ComponentSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 type TextAlign = 'left' | 'right' | 'center';
+type FlexAlignment = 'start' | 'center' | 'end';
 type HTMLInputAttrs = Omit<React.JSX.IntrinsicElements['input'], 'size'>;
 type DescopeInputExtraProps = {
     'full-width'?: boolean;
@@ -124,11 +125,11 @@ declare const Switch: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "r
 type BooleanType = {
     type: 'switch' | 'checkbox';
 };
-type Props$L = React.ComponentProps<typeof Checkbox> & React.ComponentProps<typeof Switch> & BooleanType;
-declare const Boolean: React.ForwardRefExoticComponent<Omit<Props$L, "ref"> & React.RefAttributes<HTMLInputElement>>;
+type Props$O = React.ComponentProps<typeof Checkbox> & React.ComponentProps<typeof Switch> & BooleanType;
+declare const Boolean: React.ForwardRefExoticComponent<Omit<Props$O, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
 type TooltipPosition = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'start' | 'start-top' | 'start-bottom' | 'end' | 'end-top' | 'end-bottom';
-type Props$K = {
+type Props$N = {
     text?: string;
     position?: TooltipPosition;
     hoverDelay?: number;
@@ -139,18 +140,18 @@ type Props$K = {
     children?: React.ReactNode;
 };
 declare module 'react' {
-    interface HTMLAttributes<_T> {
+    interface HTMLAttributes<T, _T = unknown> {
         slot?: string;
     }
 }
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-tooltip': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$K;
+            'descope-tooltip': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$N;
         }
     }
 }
-declare const Tooltip: React.ForwardRefExoticComponent<any>;
+declare const Tooltip: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement, unknown> & Props$N & React.RefAttributes<HTMLElement>>;
 
 interface ITooltip {
     hasTooltip?: boolean;
@@ -187,18 +188,43 @@ declare const Button: React.ForwardRefExoticComponent<Omit<React.ClassAttributes
     'data-name'?: string;
 } & ITooltip, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 
-type Props$J = {
+type Props$M = {
     digits?: number;
 };
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-passcode': DescopeInputProps & Props$J;
+            'descope-passcode': DescopeInputProps & Props$M;
         }
     }
 }
-declare const Code: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$J, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const Code: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$M, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
+type Never$1<T extends Record<string, any>> = {
+    [K in keyof T]: never;
+};
+type SpaceBetween$1 = '0' | '0.5' | '1' | '1.5' | '2' | '2.5' | '3' | '3.5' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '14' | '16' | '20' | '24' | '28' | '32';
+type Flex$1 = {
+    align?: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+    spaceBetween?: SpaceBetween$1;
+};
+type ContainerAlignment$1 = {
+    'horizontal-alignment'?: FlexAlignment | 'space-between';
+    'vertical-alignment'?: FlexAlignment;
+    'space-between'?: 'sm' | 'md' | 'lg';
+};
+type Props$L = {
+    direction?: 'row' | 'column';
+    shadow?: 'md' | 'lg' | 'xl' | '2xl';
+    borderRadius?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+    paddingX?: string;
+    paddingY?: string;
+    background?: string;
+    backgroundImageUrl?: string;
+    width?: string;
+    variant?: string;
+} & ((Flex$1 & Never$1<ContainerAlignment$1>) | (ContainerAlignment$1 & Never$1<Flex$1>));
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
@@ -206,9 +232,9 @@ declare global {
         }
     }
 }
-declare const Container$1: React.ForwardRefExoticComponent<any>;
+declare const Container$1: React.ForwardRefExoticComponent<(Props$L & React.HTMLAttributes<HTMLDivElement, unknown>) & React.RefAttributes<HTMLDivElement>>;
 
-type Props$I = {
+type Props$K = {
     vertical?: boolean;
     italic?: boolean;
     variant?: TypographyVariants;
@@ -218,15 +244,15 @@ type Props$I = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-divider': React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement> & Omit<Props$I, 'children'>;
+            'descope-divider': React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement> & Omit<Props$K, 'children'>;
         }
     }
 }
-declare const Divider: React.ForwardRefExoticComponent<Omit<Omit<any, "size"> & Props$I, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Divider: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement, unknown>, HTMLDivElement>, "size"> & Props$K, "ref"> & React.RefAttributes<HTMLDivElement>>;
 
 declare const ReactComponent: (props: SVGProps) => React.JSX.Element;
 
-type Props$H = {
+type Props$J = {
     width?: string;
     height?: string;
     alt?: string;
@@ -236,15 +262,21 @@ type Props$H = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$H;
+            'descope-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$J;
         }
     }
 }
-declare const Image: React.ForwardRefExoticComponent<any>;
+declare const Image: React.ForwardRefExoticComponent<{
+    width?: string;
+    height?: string;
+    alt?: string;
+    src: string;
+    'src-dark'?: string;
+} & ITooltip & React.HTMLAttributes<HTMLElement, unknown> & React.RefAttributes<HTMLElement>>;
 
 declare const Input: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$G = {
+type Props$I = {
     href?: string | undefined;
     italic?: boolean;
     variant?: TypographyVariants;
@@ -256,7 +288,7 @@ type Props$G = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-link': React.DetailedHTMLProps<React.HTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> & Omit<Props$G, 'children'>;
+            'descope-link': React.DetailedHTMLProps<React.HTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> & Omit<Props$I, 'children'>;
         }
     }
 }
@@ -270,12 +302,12 @@ declare const Link: React.ForwardRefExoticComponent<{
     children?: React.ReactNode;
 } & ITooltip & React.RefAttributes<HTMLAnchorElement>>;
 
-type Props$F = {
+type Props$H = {
     variant?: 'linear' | 'radial';
     size?: 'xs' | 'sm' | 'md' | 'lg';
     color?: Mode;
 };
-type LoaderType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$F>;
+type LoaderType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$H>;
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
@@ -284,22 +316,22 @@ declare global {
         }
     }
 }
-declare const Loader: React.ForwardRefExoticComponent<Props$F & React.RefAttributes<HTMLDivElement>>;
+declare const Loader: React.ForwardRefExoticComponent<Props$H & React.RefAttributes<HTMLDivElement>>;
 
-type Props$E = {
+type Props$G = {
     width?: string;
     height?: string;
 };
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-logo': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$E>;
+            'descope-logo': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$G>;
         }
     }
 }
-declare const Logo: React.ForwardRefExoticComponent<Props$E & React.RefAttributes<HTMLDivElement>>;
+declare const Logo: React.ForwardRefExoticComponent<Props$G & React.RefAttributes<HTMLDivElement>>;
 
-type Props$D = {
+type Props$F = {
     'password-label'?: string;
     'password-placeholder'?: string;
     'confirm-label'?: string;
@@ -326,11 +358,11 @@ type Props$D = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-new-password': DescopeInputProps & Props$D;
+            'descope-new-password': DescopeInputProps & Props$F;
         }
     }
 }
-declare const NewPassword: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$D, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const NewPassword: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$F, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
 declare global {
     namespace React.JSX {
@@ -350,7 +382,7 @@ declare global {
 }
 declare const Password: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$C = {
+type Props$E = {
     variant: 'countrySelection' | 'inputBox';
     'default-code'?: string;
     'phone-input-placeholder'?: string;
@@ -359,9 +391,9 @@ type Props$C = {
     'format-value'?: boolean;
     'strict-validation'?: boolean;
 } & DescopeInputProps;
-declare const Phone: React.ForwardRefExoticComponent<Omit<Props$C, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const Phone: React.ForwardRefExoticComponent<Omit<Props$E, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$B = {
+type Props$D = {
     children?: React.JSX.Element[];
     data?: string | Record<string, string>[];
 };
@@ -374,9 +406,9 @@ declare global {
         }
     }
 }
-declare const Select: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$B, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const Select: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$D, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$A = {
+type Props$C = {
     italic?: boolean;
     variant?: string;
     mode?: string;
@@ -388,8 +420,8 @@ type Props$A = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-text': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$A;
-            'descope-enriched-text': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$A & {
+            'descope-text': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$C;
+            'descope-enriched-text': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$C & {
                 readonly?: boolean;
             };
         }
@@ -425,7 +457,7 @@ declare global {
 }
 declare const TextField: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$z = {
+type Props$B = {
     width?: string;
     height?: string;
     component?: 'code' | 'text';
@@ -438,7 +470,7 @@ type Props$z = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-totp-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$z>;
+            'descope-totp-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$B>;
         }
     }
 }
@@ -453,26 +485,26 @@ declare const TOTPImage: React.ForwardRefExoticComponent<{
     'hide-when-empty'?: boolean;
 } & ITooltip & React.RefAttributes<HTMLDivElement>>;
 
-type Props$y = Omit<React.ComponentProps<typeof Link>, 'href'>;
-declare const TOTPLink: React.ForwardRefExoticComponent<Omit<Props$y, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+type Props$A = Omit<React.ComponentProps<typeof Link>, 'href'>;
+declare const TOTPLink: React.ForwardRefExoticComponent<Omit<Props$A, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
 
-type Props$x = {
+type Props$z = {
     width?: string;
     height?: string;
 };
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-notp-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$x>;
+            'descope-notp-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$z>;
         }
     }
 }
-declare const NOTPImage: React.ForwardRefExoticComponent<Props$x & React.RefAttributes<HTMLDivElement>>;
+declare const NOTPImage: React.ForwardRefExoticComponent<Props$z & React.RefAttributes<HTMLDivElement>>;
 
-type Props$w = Omit<React.ComponentProps<typeof Link>, 'href'>;
-declare const NOTPLink: React.ForwardRefExoticComponent<Omit<Props$w, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+type Props$y = Omit<React.ComponentProps<typeof Link>, 'href'>;
+declare const NOTPLink: React.ForwardRefExoticComponent<Omit<Props$y, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
 
-type Props$v = {
+type Props$x = {
     title?: string;
     description?: string;
     icon?: string;
@@ -491,13 +523,13 @@ type Props$v = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-upload-file': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$v;
+            'descope-upload-file': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$x;
         }
     }
 }
-declare const UploadFile: React.ForwardRefExoticComponent<any>;
+declare const UploadFile: React.ForwardRefExoticComponent<Props$x & React.HTMLAttributes<HTMLDivElement, unknown> & React.RefAttributes<HTMLDivElement>>;
 
-type Props$u = {
+type Props$w = {
     enabled?: boolean;
     'site-key'?: string;
     enterprise?: boolean;
@@ -516,13 +548,13 @@ declare global {
     }
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-recaptcha': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$u;
+            'descope-recaptcha': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$w;
         }
     }
 }
-declare const Recaptcha: React.ForwardRefExoticComponent<any>;
+declare const Recaptcha: React.ForwardRefExoticComponent<Props$w & React.HTMLAttributes<HTMLDivElement, unknown> & React.RefAttributes<HTMLDivElement>>;
 
-type Props$t = {
+type Props$v = {
     connector?: string;
     enterprise?: boolean;
     action?: string;
@@ -537,16 +569,16 @@ type Props$t = {
     width?: string;
     height?: string;
 };
-declare const RecaptchaV2: React.ForwardRefExoticComponent<Props$t & React.HTMLAttributes<HTMLDivElement, any> & React.RefAttributes<HTMLDivElement>>;
+declare const RecaptchaV2: React.ForwardRefExoticComponent<Props$v & React.HTMLAttributes<HTMLDivElement, any> & React.RefAttributes<HTMLDivElement>>;
 
-type Props$s = DescopeInputProps & {
+type Props$u = DescopeInputProps & {
     'default-value'?: string;
     'allow-deselect'?: boolean;
 };
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-button-selection-group': Props$s;
+            'descope-button-selection-group': Props$u;
             'descope-button-selection-group-item': React.JSX.IntrinsicElements['span'] & {
                 value: string;
                 children: string;
@@ -572,10 +604,10 @@ type SingleSelectType = {
     layout?: 'horizontal' | 'vertical';
     'label-type'?: LabelType;
 };
-type Props$r = Omit<React.ComponentProps<typeof ButtonSelectionGroup>, 'allow-deselect'> & SingleSelectType;
-declare const SingleSelect: React.ForwardRefExoticComponent<Omit<Props$r, "ref"> & React.RefAttributes<HTMLInputElement>>;
+type Props$t = Omit<React.ComponentProps<typeof ButtonSelectionGroup>, 'allow-deselect'> & SingleSelectType;
+declare const SingleSelect: React.ForwardRefExoticComponent<Omit<Props$t, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$q = DescopeInputProps & {
+type Props$s = DescopeInputProps & {
     'default-value'?: string;
     'item-label-path'?: string;
     'item-value-path'?: string;
@@ -583,7 +615,7 @@ type Props$q = DescopeInputProps & {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-combobox': Props$q;
+            'descope-combobox': Props$s;
         }
     }
 }
@@ -605,7 +637,7 @@ type Column = {
         resizable: boolean;
     };
 };
-type Props$p = {
+type Props$r = {
     identifier: any;
     children?: React.JSX.Element[];
     size?: Omit<ComponentSize, 'xl'>;
@@ -621,7 +653,7 @@ declare global {
         }
     }
 }
-declare const Grid: React.ForwardRefExoticComponent<Props$p & React.RefAttributes<HTMLInputElement>>;
+declare const Grid: React.ForwardRefExoticComponent<Props$r & React.RefAttributes<HTMLInputElement>>;
 
 type ColumnProps = {
     sortable?: boolean;
@@ -642,7 +674,7 @@ declare const GridTextColumn: React.ForwardRefExoticComponent<ColumnProps & Reac
 
 declare const GridItemDetailsColumn: React.ForwardRefExoticComponent<ColumnProps & React.RefAttributes<HTMLInputElement>>;
 
-type Props$o = {
+type Props$q = {
     mode?: string;
     size?: string;
     bordered?: boolean;
@@ -651,11 +683,11 @@ type Props$o = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-badge': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$o;
+            'descope-badge': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$q;
         }
     }
 }
-declare const Badge: React.ForwardRefExoticComponent<any>;
+declare const Badge: React.ForwardRefExoticComponent<Props$q & React.HTMLAttributes<HTMLElement, unknown> & React.RefAttributes<HTMLElement>>;
 
 declare global {
     namespace React.JSX {
@@ -664,12 +696,12 @@ declare global {
         }
     }
 }
-type Props$n = {
+type Props$p = {
     opened?: boolean;
 };
-declare const Modal: React.ForwardRefExoticComponent<Props$n & React.RefAttributes<HTMLDivElement>>;
+declare const Modal: React.ForwardRefExoticComponent<Props$p & React.RefAttributes<HTMLDivElement>>;
 
-type Props$m = DescopeInputProps & {
+type Props$o = DescopeInputProps & {
     size?: 'xs' | 'sm' | 'md' | 'lg';
     'min-items-selection'?: number;
     'max-items-selection'?: number;
@@ -677,7 +709,7 @@ type Props$m = DescopeInputProps & {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-button-multi-selection-group': Props$m & {
+            'descope-button-multi-selection-group': Props$o & {
                 'default-values'?: string;
             };
             'descope-button-selection-group-item': React.JSX.IntrinsicElements['span'] & {
@@ -704,16 +736,16 @@ type MultiSelectType = {
     'max-items-selection'?: number;
     'label-type'?: string;
 };
-type Props$l = Omit<React.ComponentProps<typeof ButtonMultiSelectionGroup>, 'default-values'> & MultiSelectType & {
+type Props$n = Omit<React.ComponentProps<typeof ButtonMultiSelectionGroup>, 'default-values'> & MultiSelectType & {
     'default-values'?: string[];
 };
-declare const MultiSelect: React.ForwardRefExoticComponent<Omit<Props$l, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const MultiSelect: React.ForwardRefExoticComponent<Omit<Props$n, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
 type Item$3 = {
     label: string;
     value: string;
 };
-type Props$k = Omit<DescopeInputProps, 'bordered' | 'label' | 'placeholder' | 'helper-text' | 'data-errormessage-pattern-mismatch' | 'data-errormessage-value-missing'> & {
+type Props$m = Omit<DescopeInputProps, 'bordered' | 'label' | 'placeholder' | 'helper-text' | 'data-errormessage-pattern-mismatch' | 'data-errormessage-value-missing'> & {
     'label-value'?: string;
     'label-attr'?: string;
     'button-label'?: string;
@@ -725,20 +757,20 @@ type Props$k = Omit<DescopeInputProps, 'bordered' | 'label' | 'placeholder' | 'h
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-mappings-field': Omit<Props$k, 'default-values' | 'options'> & {
+            'descope-mappings-field': Omit<Props$m, 'default-values' | 'options'> & {
                 'default-values'?: string;
                 options?: string;
             };
         }
     }
 }
-declare const MappingsField: React.ForwardRefExoticComponent<Omit<Props$k, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const MappingsField: React.ForwardRefExoticComponent<Omit<Props$m, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
 type Item$2 = {
     label: string;
     value: string;
 };
-type Props$j = Omit<DescopeInputProps, 'bordered' | 'label' | 'placeholder' | 'helper-text' | 'data-errormessage-pattern-mismatch' | 'data-errormessage-value-missing'> & {
+type Props$l = Omit<DescopeInputProps, 'bordered' | 'label' | 'placeholder' | 'helper-text' | 'data-errormessage-pattern-mismatch' | 'data-errormessage-value-missing'> & {
     'label-value'?: string;
     'label-attr'?: string;
     'label-group'?: string;
@@ -750,13 +782,13 @@ type Props$j = Omit<DescopeInputProps, 'bordered' | 'label' | 'placeholder' | 'h
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-saml-group-mappings': Omit<Props$j, 'options'> & {
+            'descope-saml-group-mappings': Omit<Props$l, 'options'> & {
                 options?: string;
             };
         }
     }
 }
-declare const SAMLGroupMappings: React.ForwardRefExoticComponent<Omit<Props$j, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const SAMLGroupMappings: React.ForwardRefExoticComponent<Omit<Props$l, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
 declare global {
     namespace React.JSX {
@@ -768,9 +800,20 @@ declare global {
         }
     }
 }
-declare const UserAuthMethod: React.ForwardRefExoticComponent<any>;
+declare const UserAuthMethod: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement, unknown> & {
+    label?: string;
+    'button-label'?: string;
+    fulfilled?: boolean;
+    'full-width'?: boolean;
+    methodIcon?: string;
+    methodIconDark?: string;
+    buttonIcon?: string;
+    buttonIconDark?: string;
+    fulfilledButtonIcon?: string;
+    fulfilledButtonIconDark?: string;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 
-type Props$i = {
+type Props$k = {
     'badge-tooltip-text'?: string;
     'badge-label'?: string;
     value?: string;
@@ -786,13 +829,13 @@ type Props$i = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-user-attribute': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$i;
+            'descope-user-attribute': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$k;
         }
     }
 }
-declare const UserAttribute: React.ForwardRefExoticComponent<any>;
+declare const UserAttribute: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement, unknown> & Props$k, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 
-type Props$h = {
+type Props$j = {
     img?: string;
     'display-name'?: string;
     size?: string;
@@ -801,26 +844,26 @@ type Props$h = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-avatar': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$h;
+            'descope-avatar': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$j;
         }
     }
 }
-declare const Avatar: React.ForwardRefExoticComponent<any>;
+declare const Avatar: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement, unknown> & Props$j, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 
-type Props$g = {
+type Props$i = {
     lang?: 'xml' | 'html' | 'javascript' | 'css' | 'json';
     inline?: boolean;
 };
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-code-snippet': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$g;
+            'descope-code-snippet': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$i;
         }
     }
 }
-declare const CodeSnippet: React.ForwardRefExoticComponent<any>;
+declare const CodeSnippet: React.ForwardRefExoticComponent<Props$i & React.HTMLAttributes<HTMLElement, unknown> & React.RefAttributes<HTMLElement>>;
 
-type Props$f = {
+type Props$h = {
     emptyState?: React.ReactNode;
     children?: React.ReactNode[];
     variant?: 'list' | 'tiles';
@@ -828,26 +871,26 @@ type Props$f = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$f>;
+            'descope-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$h>;
         }
     }
 }
-declare const List: React.ForwardRefExoticComponent<Props$f & React.RefAttributes<HTMLDivElement>>;
+declare const List: React.ForwardRefExoticComponent<Props$h & React.RefAttributes<HTMLDivElement>>;
 
-type Props$e = {
+type Props$g = {
     variant?: 'row' | 'tile';
     children?: React.ReactNode;
 };
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-list-item': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$e>;
+            'descope-list-item': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$g>;
         }
     }
 }
-declare const ListItem: React.ForwardRefExoticComponent<Props$e & React.RefAttributes<HTMLDivElement>>;
+declare const ListItem: React.ForwardRefExoticComponent<Props$g & React.RefAttributes<HTMLDivElement>>;
 
-type Props$d = {
+type Props$f = {
     emptyState?: React.ReactNode;
     variant?: 'list' | 'tiles' | 'custom';
     data?: any[];
@@ -856,18 +899,18 @@ type Props$d = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-apps-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$d>;
+            'descope-apps-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$f>;
         }
     }
 }
-declare const AppsList: React.ForwardRefExoticComponent<Props$d & React.RefAttributes<HTMLDivElement>>;
+declare const AppsList: React.ForwardRefExoticComponent<Props$f & React.RefAttributes<HTMLDivElement>>;
 
 type Item$1 = {
     desc: string;
     id: string;
     required?: boolean;
 };
-type Props$c = {
+type Props$e = {
     variant?: 'checkbox' | 'switch';
     data?: Item$1[];
     readonly?: boolean;
@@ -876,17 +919,17 @@ type Props$c = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-scopes-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$c>;
+            'descope-scopes-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$e>;
         }
     }
 }
-declare const ScopesList: React.ForwardRefExoticComponent<Props$c & React.RefAttributes<HTMLDivElement>>;
+declare const ScopesList: React.ForwardRefExoticComponent<Props$e & React.RefAttributes<HTMLDivElement>>;
 
 type Question$1 = {
     id: string;
     text: string;
 };
-type Props$b = {
+type Props$d = {
     questions?: Question$1[];
     readonly?: boolean;
     size?: 'xs' | 'sm' | 'md' | 'lg';
@@ -901,17 +944,17 @@ type Props$b = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-security-questions-setup': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$b>;
+            'descope-security-questions-setup': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$d>;
         }
     }
 }
-declare const SecurityQuestionsSetup: React.ForwardRefExoticComponent<Props$b & React.RefAttributes<HTMLDivElement>>;
+declare const SecurityQuestionsSetup: React.ForwardRefExoticComponent<Props$d & React.RefAttributes<HTMLDivElement>>;
 
 type Question = {
     id: string;
     text: string;
 };
-type Props$a = {
+type Props$c = {
     questions?: Question[];
     readonly?: boolean;
     size?: 'xs' | 'sm' | 'md' | 'lg';
@@ -925,23 +968,23 @@ type Props$a = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-security-questions-verify': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$a>;
+            'descope-security-questions-verify': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$c>;
         }
     }
 }
-declare const SecurityQuestionsVerify: React.ForwardRefExoticComponent<Props$a & React.RefAttributes<HTMLDivElement>>;
+declare const SecurityQuestionsVerify: React.ForwardRefExoticComponent<Props$c & React.RefAttributes<HTMLDivElement>>;
 
-type Props$9 = {
+type Props$b = {
     size: 'xs' | 'sm' | 'md' | 'lg';
 };
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-third-party-app-logo': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$9>;
+            'descope-third-party-app-logo': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$b>;
         }
     }
 }
-declare const ThirdPartyAppLogo: React.ForwardRefExoticComponent<Props$9 & React.RefAttributes<HTMLDivElement>>;
+declare const ThirdPartyAppLogo: React.ForwardRefExoticComponent<Props$b & React.RefAttributes<HTMLDivElement>>;
 
 declare global {
     namespace React.JSX {
@@ -952,7 +995,7 @@ declare global {
 }
 declare const DateField: React.ForwardRefExoticComponent<Omit<Omit<DescopeInputProps, "external-input">, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$8 = {
+type Props$a = {
     variant?: 'countrySelection' | 'inputBox';
     'default-code'?: string;
     'phone-input-label'?: string;
@@ -973,13 +1016,30 @@ type Props$8 = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-hybrid-field': React.DetailedHTMLProps<React.HTMLAttributes<HTMLInputElement>, HTMLInputElement> & PropsToAttrs<Props$8>;
+            'descope-hybrid-field': React.DetailedHTMLProps<React.HTMLAttributes<HTMLInputElement>, HTMLInputElement> & PropsToAttrs<Props$a>;
         }
     }
 }
-declare const HybridField: React.ForwardRefExoticComponent<any>;
+declare const HybridField: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement, unknown> & {
+    variant?: "countrySelection" | "inputBox";
+    'default-code'?: string;
+    'phone-input-label'?: string;
+    'phone-input-placeholder'?: string;
+    'restrict-countries'?: string;
+    'full-width'?: boolean;
+    bordered?: boolean;
+    label?: string;
+    placeholder?: string;
+    size?: ComponentSize;
+    'helper-text'?: string;
+    'data-errormessage-pattern-mismatch-email'?: string;
+    'data-errormessage-value-missing-email'?: string;
+    'data-errormessage-value-missing-phone'?: string;
+    'label-type'?: LabelType;
+    'external-input'?: boolean;
+} & HTMLInputAttrs & DescopeInputExtraProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$7 = {
+type Props$9 = {
     mode?: string;
     variant?: string;
     bordered?: boolean;
@@ -991,13 +1051,13 @@ type Props$7 = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-alert': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$7;
+            'descope-alert': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$9;
         }
     }
 }
-declare const Alert: React.ForwardRefExoticComponent<Props$7 & React.RefAttributes<HTMLElement>>;
+declare const Alert: React.ForwardRefExoticComponent<Props$9 & React.RefAttributes<HTMLElement>>;
 
-type Props$6 = {
+type Props$8 = {
     'data-connector-id'?: string;
     'connector-template'?: string;
     'min-search-length'?: number;
@@ -1006,18 +1066,18 @@ type Props$6 = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-address-field': Omit<DescopeInputProps, 'external-input'> & Props$6;
+            'descope-address-field': Omit<DescopeInputProps, 'external-input'> & Props$8;
         }
     }
 }
-declare const AddressField: React.ForwardRefExoticComponent<Omit<Omit<DescopeInputProps, "external-input"> & Props$6, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const AddressField: React.ForwardRefExoticComponent<Omit<Omit<DescopeInputProps, "external-input"> & Props$8, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
 type CountrySubdivisionCityValue = {
     country?: string;
     subdivision?: string;
     city?: string;
 };
-type Props$5 = {
+type Props$7 = {
     'hide-country'?: boolean;
     'hide-subdivision'?: boolean;
     'hide-city'?: boolean;
@@ -1037,13 +1097,13 @@ type Props$5 = {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-country-subdivision-city-field': Omit<DescopeInputProps, 'external-input' | 'value'> & Props$5;
+            'descope-country-subdivision-city-field': Omit<DescopeInputProps, 'external-input' | 'value'> & Props$7;
         }
     }
 }
-declare const CountrySubdivisionCityField: React.ForwardRefExoticComponent<Omit<Omit<DescopeInputProps, "value" | "external-input"> & Props$5, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CountrySubdivisionCityField: React.ForwardRefExoticComponent<Omit<Omit<DescopeInputProps, "value" | "external-input"> & Props$7, "ref"> & React.RefAttributes<HTMLInputElement>>;
 
-type Props$4 = React.JSX.IntrinsicElements['button'] & {
+type Props$6 = React.JSX.IntrinsicElements['button'] & {
     variant?: string;
     color?: string;
     size?: string;
@@ -1057,7 +1117,7 @@ type Props$4 = React.JSX.IntrinsicElements['button'] & {
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
-            'descope-timer-button': React.DetailedHTMLProps<React.HTMLAttributes<HTMLButtonElement>, HTMLButtonElement> & Props$4;
+            'descope-timer-button': React.DetailedHTMLProps<React.HTMLAttributes<HTMLButtonElement>, HTMLButtonElement> & Props$6;
         }
     }
 }
@@ -1073,6 +1133,37 @@ declare const TimerButton: React.ForwardRefExoticComponent<Omit<React.ClassAttri
     'timer-paused'?: boolean;
 }, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 
+type Never<T extends Record<string, any>> = {
+    [K in keyof T]: never;
+};
+type SpaceBetween = '0' | '0.5' | '1' | '1.5' | '2' | '2.5' | '3' | '3.5' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '14' | '16' | '20' | '24' | '28' | '32';
+type Flex = {
+    spaceBetween?: SpaceBetween;
+};
+type ContainerAlignment = {
+    'horizontal-alignment'?: FlexAlignment | 'space-between';
+    'vertical-alignment'?: FlexAlignment;
+    'space-between'?: 'sm' | 'md' | 'lg';
+};
+type Props$5 = {
+    shadow?: 'md' | 'lg' | 'xl' | '2xl';
+    borderRadius?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+    paddingX?: string;
+    paddingY?: string;
+    background?: string;
+    backgroundImageUrl?: string;
+    width?: string;
+    collapsible?: boolean;
+    'icon-position'?: 'right' | 'left';
+    'fill-title'?: boolean;
+    border?: boolean;
+    text?: string;
+    'icon-name'?: string;
+    collapsed?: boolean;
+    'text-align'?: 'left' | 'right' | 'center';
+    'text-variant'?: 'body1' | 'body2' | 'subtitle1' | 'h1' | 'h2' | 'h3' | 'subtitle2';
+    'text-mode'?: 'primary' | 'secondary' | 'error' | 'success';
+} & ((Flex & Never<ContainerAlignment>) | (ContainerAlignment & Never<Flex>));
 declare global {
     namespace React.JSX {
         interface IntrinsicElements {
@@ -1080,9 +1171,19 @@ declare global {
         }
     }
 }
-declare const Container: React.ForwardRefExoticComponent<any>;
+declare const Container: React.ForwardRefExoticComponent<(Props$5 & React.HTMLAttributes<HTMLDivElement, unknown>) & React.RefAttributes<HTMLDivElement>>;
 
-declare const Turnstile: React.ForwardRefExoticComponent<any>;
+type Props$4 = {
+    connector?: string;
+    action?: string;
+    textLabel?: string;
+    textVariant?: TypographyVariants;
+    textMode?: Mode;
+    textAlign?: TextAlign;
+    readonly?: boolean;
+    'full-width'?: boolean;
+};
+declare const Turnstile: React.ForwardRefExoticComponent<Props$4 & React.HTMLAttributes<HTMLDivElement, unknown> & React.RefAttributes<HTMLDivElement>>;
 
 type Item = {
     value: string;
@@ -1114,7 +1215,7 @@ type Props$2 = {
     connector?: string;
     enabled?: boolean;
 };
-declare const Hcaptcha: React.ForwardRefExoticComponent<any>;
+declare const Hcaptcha: React.ForwardRefExoticComponent<Props$2 & React.HTMLAttributes<HTMLDivElement, unknown> & React.RefAttributes<HTMLDivElement>>;
 
 type Props$1 = {
     emptyState?: React.ReactNode;