import React, { SVGProps } from 'react';

type ComponentClass = {
    cssVarList: Record<string, string>;
};
type CountryCode = {
    name: string;
    dialCode: string;
    code: string;
};
declare const IconClass: ComponentClass;
declare const CheckboxClass: ComponentClass;
declare const SwitchToggleClass: ComponentClass;
declare const ButtonClass: ComponentClass;
declare const LoaderLinearClass: ComponentClass;
declare const LoaderRadialClass: ComponentClass;
declare const ContainerClass: ComponentClass;
declare const DividerClass: ComponentClass;
declare const EmailFieldClass: ComponentClass;
declare const LinkClass: ComponentClass;
declare const LogoClass: ComponentClass;
declare const TotpImageClass: ComponentClass;
declare const NotpImageClass: ComponentClass;
declare const NumberFieldClass: ComponentClass;
declare const PasscodeClass: ComponentClass;
declare const PasswordClass: ComponentClass;
declare const TextClass: ComponentClass;
declare const EnrichedTextClass: ComponentClass;
declare const TextAreaClass: ComponentClass;
declare const TextFieldClass: ComponentClass;
declare const ImageClass: ComponentClass;
declare const PhoneFieldClass: ComponentClass & {
    CountryCodes: CountryCode[];
};
declare const PhoneFieldInputBoxClass: ComponentClass;
declare const NewPasswordClass: ComponentClass;
declare const RecaptchaClass: ComponentClass;
declare const UploadFileClass: ComponentClass;
declare const ButtonSelectionGroupClass: ComponentClass;
declare const ButtonMultiSelectionGroupClass: ComponentClass;
declare const ModalClass: ComponentClass;
declare const NotificationClass: ComponentClass;
declare const GridClass: ComponentClass;
declare const BadgeClass: ComponentClass;
declare const MultiSelectComboBoxClass: ComponentClass;
declare const MultiLineMappingsClass: ComponentClass;
declare const AvatarClass: ComponentClass;
declare const UserAttributeClass: ComponentClass;
declare const UserAuthMethodClass: ComponentClass;
declare const MappingsFieldClass: ComponentClass;
declare const SamlGroupMappingsClass: ComponentClass;
declare const PolicyValidationClass: ComponentClass;
declare const CodeSnippetClass: ComponentClass;
declare const ComboBoxClass: ComponentClass;
declare const RadioGroupClass: ComponentClass;
declare const DateFieldClass: ComponentClass;
declare const CalendarClass: ComponentClass;
declare const MonthDayFieldClass: ComponentClass;
declare const MonthDayFieldPickerClass: ComponentClass;
declare const ListClass: ComponentClass;
declare const AppsListClass: ComponentClass;
declare const ScopesListClass: ComponentClass;
declare const ThirdPartyAppLogoClass: ComponentClass;
declare const SecurityQuestionsSetupClass: ComponentClass;
declare const SecurityQuestionsVerifyClass: ComponentClass;
declare const HybridFieldClass: ComponentClass;
declare const AlertClass: ComponentClass;
declare const AddressFieldClass: ComponentClass;
declare const CountrySubdivisionCityFieldClass: ComponentClass;
declare const TimerButtonClass: ComponentClass;
declare const CollapsibleContainerClass: ComponentClass;
declare const RecoveryCodesClass: ComponentClass;
declare const HcaptchaClass: ComponentClass;
declare const OutboundAppsClass: ComponentClass;
declare const OutboundAppButtonClass: ComponentClass;
declare const TrustedDevicesClass: ComponentClass;
declare const TooltipClass: ComponentClass;
declare const HoneypotClass: ComponentClass;
declare const AttachmentClass: ComponentClass;
declare const UserPasskeysClass: 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;
    bordered?: boolean;
    label?: string;
    placeholder?: string;
    size?: ComponentSize;
    'helper-text'?: string;
    'data-errormessage-pattern-mismatch'?: string;
    'data-errormessage-value-missing'?: string;
    'label-type'?: LabelType;
    'external-input'?: boolean;
};
type DescopeInputProps = HTMLInputAttrs & DescopeInputExtraProps;
type PropsToAttrs<R extends Record<string, any>> = {
    [K in keyof R as KebabCase<K & string>]: R[K] | string;
};
type TypographyVariants = 'h1' | 'h2' | 'h3' | 'subtitle1' | 'subtitle2' | 'body1' | 'body2';
type Mode = 'primary' | 'secondary' | 'error' | 'success';
type MultiSelectProps = {
    children?: React.JSX.Element[];
    'default-values'?: string[];
};
type LabelType = 'static' | 'floating';
type CaptchaVariants = 'text' | 'image' | 'widget' | 'hide';

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-checkbox': DescopeInputProps;
        }
    }
}
declare const Checkbox: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-switch-toggle': DescopeInputProps;
        }
    }
}
declare const Switch: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

type BooleanType = {
    type: 'switch' | 'checkbox';
};
type Props$Q = React.ComponentProps<typeof Checkbox> & React.ComponentProps<typeof Switch> & BooleanType;
declare const Boolean: React.ForwardRefExoticComponent<Omit<Props$Q, "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$P = {
    text?: string;
    position?: TooltipPosition;
    hoverDelay?: number;
    hideDelay?: number;
    opened?: boolean;
    readonly?: boolean;
    staticDisplay?: boolean;
    children?: React.ReactNode;
};
declare module 'react' {
    interface HTMLAttributes<T, _T = unknown> {
        slot?: string;
    }
}
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-tooltip': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$P;
        }
    }
}
declare const Tooltip: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement, unknown> & Props$P & React.RefAttributes<HTMLElement>>;

interface ITooltip {
    hasTooltip?: boolean;
    tooltipText?: string;
    tooltipPosition?: TooltipPosition;
    tooltipHoverDelay?: number;
    tooltipHideDelay?: number;
    tooltipOpened?: boolean;
    tooltipReadOnly?: boolean;
    tooltipStaticDisplay?: boolean;
}

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-button': React.DetailedHTMLProps<React.HTMLAttributes<HTMLButtonElement>, HTMLButtonElement> & {
                size?: string;
                variant?: string;
                mode: string;
                square?: boolean;
            };
        }
    }
}
declare const Button: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
    variant?: string;
    color?: string;
    size?: string;
    loading?: boolean;
    startIcon?: string;
    startIconDark?: string;
    startIconColorText?: boolean;
    'full-width'?: boolean;
    'data-name'?: string;
} & ITooltip, "ref"> & React.RefAttributes<HTMLButtonElement>>;

type Props$O = {
    digits?: number;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-passcode': DescopeInputProps & Props$O;
        }
    }
}
declare const Code: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$O, "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$N = {
    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 {
            'descope-container': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
        }
    }
}
declare const Container$1: React.ForwardRefExoticComponent<(Props$N & React.HTMLAttributes<HTMLDivElement, unknown>) & React.RefAttributes<HTMLDivElement>>;

type Props$M = {
    vertical?: boolean;
    italic?: boolean;
    variant?: TypographyVariants;
    mode?: Mode;
    children?: React.ReactNode;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-divider': React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement> & Omit<Props$M, 'children'>;
        }
    }
}
declare const Divider: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement, unknown>, HTMLDivElement>, "size"> & Props$M, "ref"> & React.RefAttributes<HTMLDivElement>>;

declare const ReactComponent: (props: SVGProps) => React.JSX.Element;

type Props$L = {
    width?: string;
    height?: string;
    alt?: string;
    src: string;
    'src-dark'?: string;
} & ITooltip;
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$L;
        }
    }
}
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$K = {
    href?: string | undefined;
    italic?: boolean;
    variant?: TypographyVariants;
    mode?: Mode;
    textAlign?: TextAlign;
    'full-width'?: boolean;
    children?: React.ReactNode;
} & ITooltip;
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-link': React.DetailedHTMLProps<React.HTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> & Omit<Props$K, 'children'>;
        }
    }
}
declare const Link: React.ForwardRefExoticComponent<{
    href?: string | undefined;
    italic?: boolean;
    variant?: TypographyVariants;
    mode?: Mode;
    textAlign?: TextAlign;
    'full-width'?: boolean;
    children?: React.ReactNode;
} & ITooltip & React.RefAttributes<HTMLAnchorElement>>;

type Props$J = {
    variant?: 'linear' | 'radial';
    size?: 'xs' | 'sm' | 'md' | 'lg';
    color?: Mode;
};
type LoaderType = React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$J>;
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-loader-linear': LoaderType;
            'descope-loader-radial': LoaderType;
        }
    }
}
declare const Loader: React.ForwardRefExoticComponent<Props$J & React.RefAttributes<HTMLDivElement>>;

type Props$I = {
    width?: string;
    height?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-logo': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$I>;
        }
    }
}
declare const Logo: React.ForwardRefExoticComponent<Props$I & React.RefAttributes<HTMLDivElement>>;

type Props$H = {
    'password-label'?: string;
    'password-placeholder'?: string;
    'confirm-label'?: string;
    'confirm-placeholder'?: string;
    'has-confirm'?: boolean;
    'policy-label'?: string;
    'has-validation'?: boolean;
    'active-policies'?: string[];
    'data-password-policy-pattern-minlength'?: string;
    'data-password-policy-pattern-lowercase'?: string;
    'data-password-policy-pattern-uppercase'?: string;
    'data-password-policy-pattern-anyletter'?: string;
    'data-password-policy-pattern-number'?: string;
    'data-password-policy-pattern-nonalphanumeric'?: string;
    'data-password-policy-message-minlength'?: string;
    'data-password-policy-message-lowercase'?: string;
    'data-password-policy-message-uppercase'?: string;
    'data-password-policy-message-anyletter'?: string;
    'data-password-policy-message-number'?: string;
    'data-password-policy-message-nonalphanumeric'?: string;
    'data-password-policy-message-passwordstrength'?: string;
    'data-password-policy-message-disallowedchars'?: string;
    'data-password-policy-message-disallowemail'?: string;
    'data-password-policy-value-minlength'?: string;
    'data-password-policy-value-disallowedchars'?: string;
    'data-password-policy-value-email'?: string;
    'st-policy-preview-background-color'?: string;
    'st-policy-preview-padding'?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-new-password': DescopeInputProps & Props$H;
        }
    }
}
declare const NewPassword: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$H, "ref"> & React.RefAttributes<HTMLInputElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-number-field': DescopeInputProps;
        }
    }
}
declare const NumberField: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-password': DescopeInputProps;
        }
    }
}
declare const Password: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Props$G = {
    variant: 'countrySelection' | 'inputBox';
    'default-code'?: string;
    'phone-input-placeholder'?: string;
    'country-input-placeholder'?: string;
    'restrict-countries'?: string;
    'format-value'?: boolean;
    'strict-validation'?: boolean;
} & DescopeInputProps;
declare const Phone: React.ForwardRefExoticComponent<Omit<Props$G, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Props$F = {
    children?: React.JSX.Element[];
    data?: string | Record<string, string>[];
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-combo-box': DescopeInputProps & {
                data?: string;
            };
        }
    }
}
declare const Select: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & Props$F, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Props$E = {
    italic?: boolean;
    variant?: string;
    mode?: string;
    isEnriched?: boolean;
    'full-width'?: boolean;
    'text-align'?: TextAlign;
    'hide-when-empty'?: boolean;
} & ITooltip;
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-text': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$E;
            'descope-enriched-text': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$E & {
                readonly?: boolean;
            };
        }
    }
}
declare const Text: React.ForwardRefExoticComponent<Omit<{
    italic?: boolean;
    variant?: string;
    mode?: string;
    isEnriched?: boolean;
    'full-width'?: boolean;
    'text-align'?: TextAlign;
    'hide-when-empty'?: boolean;
} & ITooltip & {
    typography?: TypographyVariants;
} & Omit<React.HTMLProps<HTMLSpanElement>, "mode">, "ref"> & React.RefAttributes<HTMLElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-text-area': DescopeInputProps;
        }
    }
}
declare const Textarea: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-text-field': DescopeInputProps;
        }
    }
}
declare const TextField: React.ForwardRefExoticComponent<Omit<DescopeInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Props$D = {
    width?: string;
    height?: string;
    component?: 'code' | 'text';
    children?: string;
    variant?: TypographyVariants;
    mode?: Mode;
    'text-align'?: TextAlign;
    'hide-when-empty'?: boolean;
} & ITooltip;
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-totp-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$D>;
        }
    }
}
declare const TOTPImage: React.ForwardRefExoticComponent<{
    width?: string;
    height?: string;
    component?: "code" | "text";
    children?: string;
    variant?: TypographyVariants;
    mode?: Mode;
    'text-align'?: TextAlign;
    'hide-when-empty'?: boolean;
} & ITooltip & React.RefAttributes<HTMLDivElement>>;

type Props$C = Omit<React.ComponentProps<typeof Link>, 'href'>;
declare const TOTPLink: React.ForwardRefExoticComponent<Omit<Props$C, "ref"> & React.RefAttributes<HTMLAnchorElement>>;

type Props$B = {
    width?: string;
    height?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-notp-image': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$B>;
        }
    }
}
declare const NOTPImage: React.ForwardRefExoticComponent<Props$B & React.RefAttributes<HTMLDivElement>>;

type Props$A = Omit<React.ComponentProps<typeof Link>, 'href'>;
declare const NOTPLink: React.ForwardRefExoticComponent<Omit<Props$A, "ref"> & React.RefAttributes<HTMLAnchorElement>>;

type Props$z = {
    title?: string;
    description?: string;
    icon?: string;
    size?: ComponentSize;
    'button-label'?: string;
    'button-mode'?: string;
    'button-variant'?: string;
    accept?: string;
    name?: string;
    readonly?: boolean;
    required?: boolean;
    bordered?: boolean;
    'full-width'?: boolean;
    'data-errormessage-value-missing'?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-upload-file': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$z;
        }
    }
}
declare const UploadFile: React.ForwardRefExoticComponent<Props$z & React.HTMLAttributes<HTMLDivElement, unknown> & React.RefAttributes<HTMLDivElement>>;

type Props$y = {
    enabled?: boolean;
    'site-key'?: string;
    enterprise?: boolean;
    action?: string;
    variant?: CaptchaVariants;
    textLabel?: string;
    textVariant?: TypographyVariants;
    textMode?: Mode;
    textAlign?: TextAlign;
    'full-width'?: boolean;
    readOnly?: boolean;
};
declare global {
    interface Window {
        onRecaptchaLoadCallback: () => void;
    }
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-recaptcha': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement, any>, HTMLElement> & Props$y;
        }
    }
}
declare const Recaptcha: React.ForwardRefExoticComponent<Props$y & React.HTMLAttributes<HTMLDivElement, any> & React.RefAttributes<HTMLDivElement>>;

type Props$x = {
    connector?: string;
    enterprise?: boolean;
    action?: string;
    textLabel?: string;
    textVariant?: TypographyVariants;
    textMode?: Mode;
    textAlign?: TextAlign;
    'full-width'?: boolean;
    readOnly?: boolean;
    variant?: CaptchaVariants;
    src?: string;
    width?: string;
    height?: string;
};
declare const RecaptchaV2: React.ForwardRefExoticComponent<Props$x & React.HTMLAttributes<HTMLDivElement, any> & React.RefAttributes<HTMLDivElement>>;

type Props$w = DescopeInputProps & {
    'default-value'?: string;
    'allow-deselect'?: boolean;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-button-selection-group': Props$w;
            'descope-button-selection-group-item': React.JSX.IntrinsicElements['span'] & {
                value: string;
                children: string;
            };
        }
    }
}
declare const ButtonSelectionGroup: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & {
    'default-value'?: string;
    'allow-deselect'?: boolean;
} & {
    children?: React.JSX.Element[];
}, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Item$5 = {
    label: string;
    value: string;
};
type SingleSelectType = {
    variant?: 'buttonSelectionGroup' | 'combobox' | 'radioGroup';
    data?: Item$5[];
    allowClearValue?: boolean;
    layout?: 'horizontal' | 'vertical';
    'label-type'?: LabelType;
};
type Props$v = Omit<React.ComponentProps<typeof ButtonSelectionGroup>, 'allow-deselect'> & SingleSelectType;
declare const SingleSelect: React.ForwardRefExoticComponent<Omit<Props$v, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Props$u = DescopeInputProps & {
    'default-value'?: string;
    'item-label-path'?: string;
    'item-value-path'?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-combobox': Props$u;
        }
    }
}
declare const ComboBox: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & {
    'default-value'?: string;
    'item-label-path'?: string;
    'item-value-path'?: string;
} & {
    children?: React.JSX.Element[];
}, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Column = {
    path: '';
    header: string;
    type: 'selection' | 'text';
    attrs: {
        frozen: boolean;
        'auto-width': boolean;
        resizable: boolean;
    };
};
type Props$t = {
    identifier: any;
    children?: React.JSX.Element[];
    size?: Omit<ComponentSize, 'xl'>;
    bordered?: boolean;
    columns?: Column[];
    'column-reordering-allowed'?: boolean;
    data?: Record<string, any>;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-grid': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
        }
    }
}
declare const Grid: React.ForwardRefExoticComponent<Props$t & React.RefAttributes<HTMLInputElement>>;

type ColumnProps = {
    sortable?: boolean;
    path: string;
    header: string;
    resizable?: boolean;
    'auto-width?': boolean;
    frozen?: boolean;
};

declare const GridCustomColumn: React.ForwardRefExoticComponent<ColumnProps & {
    children: React.JSX.Element[];
} & React.RefAttributes<HTMLInputElement>>;

declare const GridSelectionColumn: React.ForwardRefExoticComponent<ColumnProps & React.RefAttributes<HTMLInputElement>>;

declare const GridTextColumn: React.ForwardRefExoticComponent<ColumnProps & React.RefAttributes<HTMLInputElement>>;

declare const GridItemDetailsColumn: React.ForwardRefExoticComponent<ColumnProps & React.RefAttributes<HTMLInputElement>>;

type Props$s = {
    mode?: string;
    size?: string;
    bordered?: boolean;
    'full-width'?: boolean;
    variant?: string;
    shrinkToIndicator?: boolean;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-badge': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$s;
        }
    }
}
declare const Badge: React.ForwardRefExoticComponent<Props$s & React.HTMLAttributes<HTMLElement, unknown> & React.RefAttributes<HTMLElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-modal': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
        }
    }
}
type Props$r = {
    opened?: boolean;
};
declare const Modal: React.ForwardRefExoticComponent<Props$r & React.RefAttributes<HTMLDivElement>>;

type Props$q = DescopeInputProps & {
    size?: 'xs' | 'sm' | 'md' | 'lg';
    'min-items-selection'?: number;
    'max-items-selection'?: number;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-button-multi-selection-group': Props$q & {
                'default-values'?: string;
            };
            'descope-button-selection-group-item': React.JSX.IntrinsicElements['span'] & {
                value: string;
                children: string;
            };
        }
    }
}
declare const ButtonMultiSelectionGroup: React.ForwardRefExoticComponent<Omit<HTMLInputAttrs & DescopeInputExtraProps & {
    size?: "xs" | "sm" | "md" | "lg";
    'min-items-selection'?: number;
    'max-items-selection'?: number;
} & MultiSelectProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Item$4 = {
    label: string;
    value: string;
};
type MultiSelectType = {
    variant?: 'buttonSelectionGroup' | 'combobox' | 'dynamicCombobox';
    data?: Item$4[];
    'min-items-selection'?: number;
    'max-items-selection'?: number;
    'label-type'?: string;
};
type Props$p = Omit<React.ComponentProps<typeof ButtonMultiSelectionGroup>, 'default-values'> & MultiSelectType & {
    'default-values'?: string[];
};
declare const MultiSelect: React.ForwardRefExoticComponent<Omit<Props$p, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Item$3 = {
    label: string;
    value: string;
};
type Props$o = Omit<DescopeInputProps, 'bordered' | 'label' | 'placeholder' | 'helper-text' | 'data-errormessage-pattern-mismatch' | 'data-errormessage-value-missing'> & {
    'label-value'?: string;
    'label-attr'?: string;
    'button-label'?: string;
    separator?: string;
    size?: 'xs' | 'sm' | 'md' | 'lg';
    'default-values'?: Record<string, string>[];
    options?: Item$3[];
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-mappings-field': Omit<Props$o, 'default-values' | 'options'> & {
                'default-values'?: string;
                options?: string;
            };
        }
    }
}
declare const MappingsField: React.ForwardRefExoticComponent<Omit<Props$o, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Item$2 = {
    label: string;
    value: string;
};
type Props$n = Omit<DescopeInputProps, 'bordered' | 'label' | 'placeholder' | 'helper-text' | 'data-errormessage-pattern-mismatch' | 'data-errormessage-value-missing'> & {
    'label-value'?: string;
    'label-attr'?: string;
    'label-group'?: string;
    'button-label'?: string;
    separator?: string;
    size?: 'xs' | 'sm' | 'md' | 'lg';
    options?: Item$2[];
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-saml-group-mappings': Omit<Props$n, 'options'> & {
                options?: string;
            };
        }
    }
}
declare const SAMLGroupMappings: React.ForwardRefExoticComponent<Omit<Props$n, "ref"> & React.RefAttributes<HTMLInputElement>>;

type DataEntry = string[] | {
    label?: string;
    options?: string[];
};
type Props$m = {
    size?: 'xs' | 'sm' | 'md' | 'lg';
    disabled?: boolean;
    readonly?: boolean;
    'full-width'?: boolean;
    'max-rows'?: number;
    'first-label'?: string;
    'second-label'?: string;
    'first-placeholder'?: string;
    'second-placeholder'?: string;
    'first-value-key'?: string;
    'second-value-key'?: string;
    'merge-rows'?: boolean;
    data?: Record<string, DataEntry>;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-multi-line-mappings': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Omit<Props$m, 'data'> & {
                data?: string;
            };
        }
    }
}
declare const MultiLineMappings: React.ForwardRefExoticComponent<Props$m & React.RefAttributes<HTMLElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-user-auth-method': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & {
                methodIcon?: string;
                buttonIcon?: string;
            };
        }
    }
}
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$l = {
    'badge-tooltip-text'?: string;
    'badge-label'?: string;
    value?: string;
    placeholder?: string;
    label?: string;
    'full-width'?: boolean;
    required?: boolean;
    deleteIconLight?: string;
    editIconLight?: string;
    deleteIconDark?: string;
    editIconDark?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-user-attribute': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$l;
        }
    }
}
declare const UserAttribute: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement, unknown> & Props$l, "ref"> & React.RefAttributes<HTMLButtonElement>>;

type Props$k = {
    img?: string;
    'display-name'?: string;
    size?: string;
    editable?: boolean;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-avatar': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$k;
        }
    }
}
declare const Avatar: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement, unknown> & Props$k, "ref"> & React.RefAttributes<HTMLButtonElement>>;

type Props$j = {
    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$j;
        }
    }
}
declare const CodeSnippet: React.ForwardRefExoticComponent<Props$j & React.HTMLAttributes<HTMLElement, unknown> & React.RefAttributes<HTMLElement>>;

type Props$i = {
    emptyState?: React.ReactNode;
    children?: React.ReactNode[];
    variant?: 'list' | 'tiles';
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$i>;
        }
    }
}
declare const List: React.ForwardRefExoticComponent<Props$i & React.RefAttributes<HTMLDivElement>>;

type Props$h = {
    variant?: 'row' | 'tile';
    children?: React.ReactNode;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-list-item': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$h>;
        }
    }
}
declare const ListItem: React.ForwardRefExoticComponent<Props$h & React.RefAttributes<HTMLDivElement>>;

type Props$g = {
    emptyState?: React.ReactNode;
    variant?: 'list' | 'tiles' | 'custom';
    data?: any[];
    readonly?: boolean;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-apps-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$g>;
        }
    }
}
declare const AppsList: React.ForwardRefExoticComponent<Props$g & React.RefAttributes<HTMLDivElement>>;

type Item$1 = {
    desc: string;
    id: string;
    required?: boolean;
};
type Props$f = {
    variant?: 'checkbox' | 'switch';
    data?: Item$1[];
    readonly?: boolean;
    size: 'xs' | 'sm' | 'md' | 'lg';
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-scopes-list': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$f>;
        }
    }
}
declare const ScopesList: React.ForwardRefExoticComponent<Props$f & React.RefAttributes<HTMLDivElement>>;

type Question$1 = {
    id: string;
    text: string;
};
type Props$e = {
    questions?: Question$1[];
    readonly?: boolean;
    size?: 'xs' | 'sm' | 'md' | 'lg';
    'st-gap'?: string;
    count?: number;
    'full-width'?: boolean;
    'question-label'?: string;
    'answer-label'?: string;
    'question-placeholder'?: string;
    'answer-placeholder'?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-security-questions-setup': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$e>;
        }
    }
}
declare const SecurityQuestionsSetup: React.ForwardRefExoticComponent<Props$e & React.RefAttributes<HTMLDivElement>>;

type Question = {
    id: string;
    text: string;
};
type Props$d = {
    questions?: Question[];
    readonly?: boolean;
    size?: 'xs' | 'sm' | 'md' | 'lg';
    'st-gap'?: string;
    'full-width'?: boolean;
    'answer-placeholder'?: string;
    'question-mode'?: string;
    'st-question-text-align'?: string;
    'answer-data-errormessage-value-missing'?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-security-questions-verify': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$d>;
        }
    }
}
declare const SecurityQuestionsVerify: React.ForwardRefExoticComponent<Props$d & React.RefAttributes<HTMLDivElement>>;

type Props$c = {
    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$c>;
        }
    }
}
declare const ThirdPartyAppLogo: React.ForwardRefExoticComponent<Props$c & React.RefAttributes<HTMLDivElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-date-field': Omit<DescopeInputProps, 'external-input'>;
        }
    }
}
declare const DateField: React.ForwardRefExoticComponent<Omit<Omit<DescopeInputProps, "external-input">, "ref"> & React.RefAttributes<HTMLInputElement>>;

type MonthDayFieldProps = Omit<DescopeInputProps, 'external-input'>;
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-month-day-field': MonthDayFieldProps;
        }
    }
}
declare const MonthDayField: React.ForwardRefExoticComponent<Omit<MonthDayFieldProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Props$b = {
    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;
} & DescopeInputProps;
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-hybrid-field': React.DetailedHTMLProps<React.HTMLAttributes<HTMLInputElement>, HTMLInputElement> & PropsToAttrs<Props$b>;
        }
    }
}
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$a = {
    mode?: string;
    variant?: string;
    bordered?: boolean;
    children?: string;
    'text-align'?: TextAlign;
    'full-width'?: boolean;
    'link-target-blank'?: boolean;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-alert': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$a;
        }
    }
}
declare const Alert: React.ForwardRefExoticComponent<Props$a & React.RefAttributes<HTMLElement>>;

type Props$9 = {
    'data-connector-id'?: string;
    'connector-template'?: string;
    'min-search-length'?: number;
    'allow-custom-value'?: boolean;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-address-field': Omit<DescopeInputProps, 'external-input'> & Props$9;
        }
    }
}
declare const AddressField: React.ForwardRefExoticComponent<Omit<Omit<DescopeInputProps, "external-input"> & Props$9, "ref"> & React.RefAttributes<HTMLInputElement>>;

type CountrySubdivisionCityValue = {
    country?: string;
    subdivision?: string;
    city?: string;
};
type Props$8 = {
    'hide-country'?: boolean;
    'hide-subdivision'?: boolean;
    'hide-city'?: boolean;
    'default-country'?: string;
    'allowed-countries'?: string;
    'pinned-countries'?: string;
    'country-label'?: string;
    'subdivision-label'?: string;
    'city-label'?: string;
    'country-placeholder'?: string;
    'subdivision-placeholder'?: string;
    'city-placeholder'?: string;
    'data-source-base-url'?: string;
    lang?: string;
    value?: CountrySubdivisionCityValue;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-country-subdivision-city-field': Omit<DescopeInputProps, 'external-input' | 'value'> & Props$8;
        }
    }
}
declare const CountrySubdivisionCityField: React.ForwardRefExoticComponent<Omit<Omit<DescopeInputProps, "value" | "external-input"> & Props$8, "ref"> & React.RefAttributes<HTMLInputElement>>;

type Props$7 = React.JSX.IntrinsicElements['button'] & {
    variant?: string;
    color?: string;
    size?: string;
    horizontal?: boolean;
    'text-align'?: TextAlign;
    'full-width'?: boolean;
    'timer-seconds'?: number;
    'timer-hide-icon'?: boolean;
    'timer-paused'?: boolean;
    'timer-position'?: 'start' | 'end';
    'timer-inside'?: boolean;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-timer-button': React.DetailedHTMLProps<React.HTMLAttributes<HTMLButtonElement>, HTMLButtonElement> & Props$7;
        }
    }
}
declare const TimerButton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
    variant?: string;
    color?: string;
    size?: string;
    horizontal?: boolean;
    'text-align'?: TextAlign;
    'full-width'?: boolean;
    'timer-seconds'?: number;
    'timer-hide-icon'?: boolean;
    'timer-paused'?: boolean;
    'timer-position'?: "start" | "end";
    'timer-inside'?: 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$6 = {
    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 {
            'descope-collapsible-container': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
        }
    }
}
declare const Container: React.ForwardRefExoticComponent<(Props$6 & React.HTMLAttributes<HTMLDivElement, unknown>) & React.RefAttributes<HTMLDivElement>>;

type Props$5 = {
    connector?: string;
    action?: string;
    textLabel?: string;
    textVariant?: TypographyVariants;
    textMode?: Mode;
    textAlign?: TextAlign;
    readonly?: boolean;
    'full-width'?: boolean;
};
declare const Turnstile: React.ForwardRefExoticComponent<Props$5 & React.HTMLAttributes<HTMLDivElement, unknown> & React.RefAttributes<HTMLDivElement>>;

type Item = {
    value: string;
};
type Props$4 = {
    variant?: string;
    mode?: string;
    'text-align': TextAlign;
    'full-width': boolean;
    data?: Item[];
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-recovery-codes': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$4>;
        }
    }
}
declare const RecoveryCodesList: React.ForwardRefExoticComponent<Props$4 & React.RefAttributes<HTMLDivElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-hcaptcha': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & Props$3;
        }
    }
}
type Props$3 = {
    connector?: string;
    enabled?: boolean;
};
declare const Hcaptcha: React.ForwardRefExoticComponent<Props$3 & React.HTMLAttributes<HTMLDivElement, unknown> & React.RefAttributes<HTMLDivElement>>;

type Props$2 = {
    emptyState?: React.ReactNode;
    size?: string;
    data?: any[];
    readonly?: boolean;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-outbound-apps': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$2>;
        }
    }
}
declare const OutboundApps: React.ForwardRefExoticComponent<Props$2 & React.RefAttributes<HTMLDivElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-outbound-app-button': React.DetailedHTMLProps<React.HTMLAttributes<HTMLButtonElement>, HTMLButtonElement> & {
                label?: string;
                iconSrc?: string;
                size?: string;
                variant?: string;
                mode: string;
                square?: boolean;
            };
        }
    }
}
declare const OutboundAppButton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
    children?: string;
    label?: string;
    iconSrc?: string;
    iconFill?: boolean;
    variant?: string;
    color?: string;
    size?: string;
    loading?: boolean;
    'full-width'?: boolean;
    'data-name'?: string;
}, "ref"> & React.RefAttributes<HTMLButtonElement>>;

type Device = {
    id: string;
    name: string;
    deviceType: 'desktop' | 'mobile' | 'tablet' | 'unknown';
    lastLoginDate: number;
};
type Props$1 = {
    emptyState?: React.ReactNode;
    data?: Device[];
    format?: string;
    readonly?: boolean;
    'full-width'?: boolean;
    'hide-actions'?: boolean;
    'remove-device-label'?: string;
    'current-device-label'?: string;
    'last-login-label'?: string;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-trusted-devices': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & PropsToAttrs<Props$1>;
        }
    }
}
declare const TrustedDevices: React.ForwardRefExoticComponent<Props$1 & React.RefAttributes<HTMLDivElement>>;

declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-ponyhot': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>;
        }
    }
}
interface HoneypotProps {
    name: string;
    type: 'text' | 'password' | 'address' | 'url' | 'tel';
}
declare const Honeypot: React.ForwardRefExoticComponent<HoneypotProps & React.RefAttributes<HTMLElement>>;

declare const TenantSelector: React.ForwardRefExoticComponent<{
    children?: React.JSX.Element[];
} & React.RefAttributes<HTMLInputElement>>;

type Position = 'top-start' | 'top-end' | 'top-center' | 'bottom-start' | 'bottom-end' | 'bottom-center';
type Props = {
    position?: Position;
    attachment?: React.ReactElement<React.HTMLAttributes<HTMLElement>>;
    offsetX?: number;
    offsetY?: number;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-attachment': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & {
                position?: Position;
                offsetX?: number;
                offsetY?: number;
            };
        }
    }
}
declare const Attachment: React.ForwardRefExoticComponent<Props & React.HTMLAttributes<HTMLElement, unknown> & React.RefAttributes<HTMLElement>>;

declare const LastAuthBadge: React.ForwardRefExoticComponent<Omit<Omit<{
    position?: "top-start" | "top-end" | "bottom-start" | "bottom-end" | "top-center" | "bottom-center";
    attachment?: React.ReactElement<React.HTMLAttributes<HTMLElement>>;
    offsetX?: number;
    offsetY?: number;
} & React.HTMLAttributes<HTMLElement, unknown> & React.RefAttributes<HTMLElement>, "attachment"> & {
    badgeLabel?: string;
} & React.HTMLAttributes<HTMLElement, unknown>, "ref"> & React.RefAttributes<HTMLElement>>;

type PasskeyType = 'apple' | 'google' | 'windows' | 'chrome' | 'edge' | 'samsung' | '1password' | 'bitwarden' | 'lastpass' | 'dashlane' | 'keeper' | 'keepassxc' | 'proton' | 'nordpass' | 'enpass' | 'key' | 'phone' | 'other';
type Passkey = {
    id: string;
    name: string;
    passkeyType: PasskeyType;
    createdAt: number;
};
declare global {
    namespace React.JSX {
        interface IntrinsicElements {
            'descope-user-passkeys': React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement> & {
                label?: string;
                'add-button-label'?: string;
                'allow-remove'?: boolean;
                format?: string;
                'created-at-label'?: string;
                'full-width'?: boolean;
                data?: Passkey[] | string;
            };
        }
    }
}
declare const UserPasskeys: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLElement, unknown> & {
    label?: string;
    addButtonLabel?: string;
    removeButtonLabel?: string;
    createdAtLabel?: string;
    allowRemove?: boolean;
    format?: string;
    readOnly?: boolean;
    'full-width'?: boolean;
    methodIcon?: string;
    methodIconDark?: string;
    buttonIcon?: string;
    buttonIconDark?: string;
    removeIcon?: string;
    removeIconDark?: string;
    data?: Passkey[] | string;
} & React.RefAttributes<HTMLElement>>;

interface IComponentThemeManager {
    currentThemeName: string;
    currentTheme: Theme;
    themes: Record<string, string>;
    hasThemes: boolean;
}
type Palette = {
    main: string;
    light: string;
    highlight: string;
    dark: string;
    contrast: string;
};
declare const globalsThemeToStyle: (theme: string, themeName: string) => string;
declare const createComponentsTheme: (componentsTheme: Record<string, string>) => Record<string, any>;
declare const themeToStyle: (theme: Theme, themeName?: string) => Record<string, any>;
declare const componentsThemeManager: IComponentThemeManager;
declare const genColor: (val: string, theme?: string) => Palette;
declare const themeVars: Theme;
declare const defaultTheme: Theme;
declare const darkTheme: Theme;

type Theme = {
    globals: {
        colors: Record<string, string>;
        fonts: Record<string, any>;
        typography: Record<string, any>;
        shadow: Record<string, string>;
        spacing: Record<string, string>;
        radius: Record<string, string>;
        border: Record<string, string>;
    };
    components: {
        button: Record<string, any>;
        textField: Record<string, any>;
        logo: Record<string, any>;
        container: Record<string, any>;
        link: Record<string, any>;
        text: Record<string, any>;
        inputWrapper: Record<string, any>;
        buttonSelectionGroupItem: Record<string, any>;
        buttonMultiSelectionGroup: Record<string, any>;
        tooltip: Record<string, any>;
    };
};

export { AddressField, AddressFieldClass, Alert, AlertClass, AppsList, AppsListClass, Attachment, AttachmentClass, Avatar, AvatarClass, Badge, BadgeClass, Boolean, Button, ButtonClass, ButtonMultiSelectionGroupClass, ButtonSelectionGroupClass, CalendarClass, Checkbox, CheckboxClass, Code, CodeSnippet, CodeSnippetClass, Container as CollapsibleContainer, CollapsibleContainerClass, ComboBox, ComboBoxClass, Container$1 as Container, ContainerClass, CountrySubdivisionCityField, CountrySubdivisionCityFieldClass, DateField, DateFieldClass, Divider, DividerClass, EmailFieldClass, EnrichedTextClass, Grid, GridClass, GridCustomColumn, GridItemDetailsColumn, GridSelectionColumn, GridTextColumn, Hcaptcha, HcaptchaClass, Honeypot, HoneypotClass, HybridField, HybridFieldClass, IconClass, Image, ImageClass, Input, LastAuthBadge, Link, LinkClass, List, ListClass, ListItem, Loader, LoaderLinearClass, LoaderRadialClass, Logo, LogoClass, MappingsField, MappingsFieldClass, Modal, ModalClass, MonthDayField, MonthDayFieldClass, MonthDayFieldPickerClass, MultiLineMappings, MultiLineMappingsClass, MultiSelect, MultiSelectComboBoxClass, NOTPImage, NOTPLink, NewPassword, NewPasswordClass, NotificationClass, NotpImageClass, NumberField, NumberFieldClass, OutboundAppButton, OutboundAppButtonClass, OutboundApps, OutboundAppsClass, PasscodeClass, Password, PasswordClass, Phone, PhoneFieldClass, PhoneFieldInputBoxClass, PolicyValidationClass, RadioGroupClass, Recaptcha, RecaptchaClass, RecaptchaV2, RecoveryCodesClass, RecoveryCodesList, SAMLGroupMappings, SamlGroupMappingsClass, ScopesList, ScopesListClass, SecurityQuestionsSetup, SecurityQuestionsSetupClass, SecurityQuestionsVerify, SecurityQuestionsVerifyClass, Select, SingleSelect, Switch, SwitchToggleClass, TOTPImage, TOTPLink, TenantSelector, Text, TextAreaClass, TextClass, TextField, TextFieldClass, Textarea, ThirdPartyAppLogo, ThirdPartyAppLogoClass, TimerButton, TimerButtonClass, Tooltip, TooltipClass, TotpImageClass, TrustedDevices, TrustedDevicesClass, Turnstile, UploadFile, UploadFileClass, UserAttribute, UserAttributeClass, UserAuthMethod, UserAuthMethodClass, UserPasskeys, UserPasskeysClass, ReactComponent as apple, ReactComponent as authenticator, componentsThemeManager, createComponentsTheme, darkTheme, defaultTheme, ReactComponent as discord, ReactComponent as edit, ReactComponent as facebook, ReactComponent as fingerprint, genColor, ReactComponent as github, ReactComponent as gitlab, globalsThemeToStyle, ReactComponent as google, ReactComponent as linkedin, ReactComponent as lock, ReactComponent as microsoft, ReactComponent as passkey, ReactComponent as password, ReactComponent as plus, ReactComponent as reload, ReactComponent as sessiontoken, ReactComponent as slack, ReactComponent as sso, themeToStyle, themeVars, ReactComponent as whatsapp };
export type { Theme };
