export { _ as FontLoader, T as ThemeProvider, a as theme } from './index-477f01b8.js';
export { Theme, default as yogaTheme } from './Theme/theme/theme.js';
export { v3theme } from './Theme/theme/v3theme.js';
export { default as createTheme } from './Theme/helpers/themeGenerator/themeGenerator.js';
import * as prop_types from 'prop-types';
import prop_types__default, { string, bool, func, node, number, elementType } from 'prop-types';
import React from 'react';
import * as styled_components from 'styled-components';
export { _ as Icon } from './Icon-19f6da82.js';
export { N as NavigationMenu } from './NavigationMenu-8c022497.js';
import '@gympass/yoga-tokens/global/transition';
import '@gympass/yoga-tokens';
import './Actions-752d7514.js';

declare function Accordion({ title, subtitle, children, disabled, expanded, small, hasHorizontalPadding, ...props }: {
    [x: string]: any;
    title: any;
    subtitle: any;
    children: any;
    disabled?: boolean | undefined;
    expanded?: boolean | undefined;
    small?: boolean | undefined;
    hasHorizontalPadding?: boolean | undefined;
}): JSX.Element;
declare namespace Accordion {
    namespace propTypes {
        export { string as title };
        export { string as subtitle };
        export const children: prop_types.Validator<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export { bool as disabled };
        export { bool as expanded };
        export { bool as small };
        export { bool as hasHorizontalPadding };
    }
}

/** Buttons make common actions more obvious and help users more easily perform them. Buttons use labels and sometimes icons to communicate the action that will occur when the user touches them. */
declare const Button: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

/** Lists are a continuous group of text or images. They are composed of items
containing primary and supplemental actions, which are represented by icons and
text. */
declare const List: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare const _default$7: React.ForwardRefExoticComponent<{
    [x: string]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: number]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: symbol]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
} & {
    theme?: any;
}>;

declare const _default$6: React.ForwardRefExoticComponent<{
    [x: string]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: number]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: symbol]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
} & {
    theme?: any;
}>;

declare function RadioGroup({ name, onChange, selectedValue, small, full, children, style, ...rest }: {
    [x: string]: any;
    name?: string | undefined;
    onChange?: (() => void) | undefined;
    selectedValue?: string | undefined;
    small?: boolean | undefined;
    full?: boolean | undefined;
    children?: null | undefined;
    style?: {} | undefined;
}): JSX.Element;
declare namespace RadioGroup {
    namespace propTypes {
        export { string as name };
        export { func as onChange };
        export const selectedValue: prop_types.Requireable<string | number>;
        export { bool as small };
        export { bool as full };
        export { node as children };
        export const style: prop_types.Requireable<prop_types.InferProps<{}>>;
    }
}

declare const Card: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare function PlanCard({ children, discount, variant, ...rest }: {
    [x: string]: any;
    children: any;
    discount: any;
    variant?: string | undefined;
}): JSX.Element;
declare namespace PlanCard {
    namespace propTypes {
        export { node as children };
        export { string as discount };
        export { string as variant };
    }
    const displayName: string;
}

declare const _default$5: React.ForwardRefExoticComponent<{
    [x: string]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: number]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: symbol]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
} & {
    theme?: any;
}>;

declare function limitChildren(props: any, propName: any, componentName: any): Error | null;

/** Stepper is responsible for the logic that drives a stepped workflow, it
provides a wizard-like workflow by dividing content into logical steps. */
declare function Stepper({ children, activeStep, secondary, ...rest }: {
    [x: string]: any;
    children: any;
    activeStep?: number | undefined;
    secondary?: boolean | undefined;
}): JSX.Element;
declare namespace Stepper {
    const displayName: string;
    namespace propTypes {
        export const children: (props: any, propName: any, componentName: any) => undefined;
        export { limitChildren as activeStep };
        export { bool as secondary };
    }
}

declare const Container: styled_components.StyledComponent<string, any, {}, never>;

declare const Row: styled_components.StyledComponent<string, any, {}, never>;

declare const Col: styled_components.StyledComponent<string, any, {}, never>;

declare const Hide: styled_components.StyledComponent<string, any, {}, never>;

declare const Display1: styled_components.StyledComponent<string, any, {}, never>;
declare const Display2: styled_components.StyledComponent<string, any, {}, never>;
declare const Display3: styled_components.StyledComponent<string, any, {}, never>;
declare const Display4: styled_components.StyledComponent<string, any, {}, never>;
declare const DisplayNumber: styled_components.StyledComponent<string, any, {}, never>;
declare const H1: styled_components.StyledComponent<string, any, {}, never>;
declare const H2: styled_components.StyledComponent<string, any, {}, never>;
declare const H3: styled_components.StyledComponent<string, any, {}, never>;
declare const H4: styled_components.StyledComponent<string, any, {}, never>;
declare const H5: styled_components.StyledComponent<string, any, {}, never>;
declare const Body1: styled_components.StyledComponent<string, any, {}, never>;
declare const Body2: styled_components.StyledComponent<string, any, {}, never>;
declare const Caption: styled_components.StyledComponent<string, any, {}, never>;
declare const Overline: styled_components.StyledComponent<string, any, {}, never>;
declare const SectionTitle: styled_components.StyledComponent<string, any, {}, never>;
declare const SmallestException: styled_components.StyledComponent<string, any, {}, never>;
declare function Text({ inverted, fontSize, light, bold, ...rest }: {
    [x: string]: any;
    inverted?: boolean | undefined;
    fontSize?: string | undefined;
    light?: boolean | undefined;
    bold?: boolean | undefined;
}): JSX.Element;
declare namespace Text {
    export const displayName: string;
    export { Display1 };
    export { Display2 };
    export { Display3 };
    export { Display4 };
    export { DisplayNumber };
    export { H1 };
    export { H2 };
    export { H3 };
    export { H4 };
    export { H5 };
    export { Body1 };
    export { Body2 };
    export { Caption };
    export { Overline };
    export { SectionTitle };
    export { SmallestException };
    export { Small };
    export { Tiny };
    export { Light };
    export { Regular };
    export { Medium };
    export { Bold };
    export { Black };
    export namespace propTypes {
        export { bool as inverted };
        export { number as numberOfLines };
        export const variant: (props: any, propName: any, componentName: any, ...rest: any[]) => any;
        export const size: (props: any, propName: any, componentName: any, ...rest: any[]) => any;
        export { bool as light };
        export { bool as bold };
        export { fontSizes as fontSize };
    }
}
declare const Small: styled_components.StyledComponent<string, any, {}, never>;
declare const Tiny: styled_components.StyledComponent<string, any, {}, never>;
declare const Light: styled_components.StyledComponent<string, any, {}, never>;
declare const Regular: styled_components.StyledComponent<string, any, {}, never>;
declare const Medium: styled_components.StyledComponent<string, any, {}, never>;
declare const Bold: styled_components.StyledComponent<string, any, {}, never>;
declare const Black: styled_components.StyledComponent<string, any, {}, never>;

declare const fontSizes: prop_types.Requireable<string>;

declare const _default$4: React.ForwardRefExoticComponent<{
    [x: string]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: number]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: symbol]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
} & {
    theme?: any;
}>;

/** Tags should be keywords to categorize or organize an item. */
declare function Tag({ children, variant, small, ellipsis, ...rest }: {
    [x: string]: any;
    children: any;
    variant?: string | undefined;
    small?: boolean | undefined;
    ellipsis?: boolean | undefined;
}): JSX.Element;
declare namespace Tag {
    namespace propTypes {
        export const variant: prop_types.Requireable<string>;
        export const children: prop_types.Validator<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export { bool as small };
        export { bool as ellipsis };
    }
}

declare const Input: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

/** The Progress is a component used to indicate a progress of an indicator
 * of quantity. The use of labels numeric or alphabetic can increase the user
 * understanding. */
declare const Progress: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

/** Gympass Dropdown is a multiple choice type of menu. */
declare const Dropdown: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

/**
 * TextArea is a type of text field which has a larger initiation size to
 * encourage a bigger user input. This component has a fixed height and the text
 * lines are increased when the input reaches the limit of lines established for
 * the field. This action creates a vertical scroll inside the component.
 */
declare const TextArea: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

/** The autocomplete is a normal input field enhanced by a panel of suggested options. */
declare const AutoComplete: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare const _default$3: React.ForwardRefExoticComponent<{
    [x: string]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: number]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: symbol]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
} & {
    theme?: any;
}>;

declare const Box: styled_components.StyledComponent<string, any, {}, never>;

declare const _default$2: React.MemoExoticComponent<React.ForwardRefExoticComponent<{
    [x: string]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: number]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: symbol]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
} & {
    theme?: any;
}>>;

/**
 * The Avatar component is used to display the image.
 * It has two shapes: default and circle
 */
declare const Avatar: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare const BottomSheet: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare const Dialog: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare const _default$1: React.ForwardRefExoticComponent<{
    [x: string]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: number]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: symbol]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
} & {
    theme?: any;
}>;

declare function Header({ link, logo, children, ...props }: {
    [x: string]: any;
    link?: null | undefined;
    logo?: null | undefined;
    children?: null | undefined;
}): JSX.Element;
declare namespace Header {
    namespace propTypes {
        export { string as link };
        export { node as children };
        export { elementType as logo };
    }
}

declare function Menu({ children, onMouseHover }: {
    children: any;
    onMouseHover?: boolean | undefined;
}): JSX.Element;
declare namespace Menu {
    namespace propTypes {
        export const children: prop_types.Validator<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export { bool as onMouseHover };
    }
    const displayName: string;
}

/** A banner is a component that displays a prominent message. It can have related action buttons on it or not. */
declare const Banner: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare function Heading({ children, noPadding, ...props }: {
    [x: string]: any;
    children: any;
    noPadding?: boolean | undefined;
}): JSX.Element;
declare namespace Heading {
    namespace propTypes {
        export const children: prop_types__default.Requireable<string | number | boolean | prop_types__default.ReactElementLike | prop_types__default.ReactNodeArray>;
        export { bool as noPadding };
        export const bg: prop_types__default.Requireable<string>;
    }
}

declare function Feedback({ variant, title, description, children, center, ...props }: {
    [x: string]: any;
    variant: any;
    title: any;
    description: any;
    children: any;
    center?: boolean | undefined;
}): JSX.Element;
declare namespace Feedback {
    namespace propTypes {
        export const variant: prop_types.Validator<string>;
        export { string as title };
        export const description: prop_types.Validator<string | (string | null | undefined)[]>;
        export const children: prop_types.Requireable<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export { bool as center };
    }
}

declare function Datepicker({ fullWidth, type, placeholder, startDate, endDate, onSelectSingle, disabled, onSelectRange, customOnSelectRange, disablePastDates, disableFutureDates, disablePastFrom, disableFutureFrom, error, onOpen, displayEndDateOnly, locale, ...props }: {
    [x: string]: any;
    fullWidth?: boolean | undefined;
    type: any;
    placeholder: any;
    startDate: any;
    endDate: any;
    onSelectSingle: any;
    disabled?: boolean | undefined;
    onSelectRange: any;
    customOnSelectRange: any;
    disablePastDates?: boolean | undefined;
    disableFutureDates?: boolean | undefined;
    disablePastFrom: any;
    disableFutureFrom: any;
    error: any;
    onOpen: any;
    displayEndDateOnly?: boolean | undefined;
    locale: any;
}): JSX.Element;
declare namespace Datepicker {
    namespace propTypes {
        export { bool as fullWidth };
        export const type: prop_types.Validator<string>;
        export { string as placeholder };
        export const startDate: prop_types.Requireable<Date>;
        export const endDate: prop_types.Requireable<Date>;
        export { bool as disabled };
        export { func as onSelectSingle };
        export { func as onSelectRange };
        export { func as customOnSelectRange };
        export { bool as disablePastDates };
        export { bool as disableFutureDates };
        export const disablePastFrom: prop_types.Requireable<Date>;
        export const disableFutureFrom: prop_types.Requireable<Date>;
        export { string as error };
        export { func as onOpen };
        export { bool as displayEndDateOnly };
        export { string as locale };
    }
}

declare const Drawer: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare function Skeleton({ animation, color, ...rest }: {
    [x: string]: any;
    animation?: string | undefined;
    color?: string | undefined;
}): JSX.Element;
declare namespace Skeleton {
    namespace propTypes {
        const color: prop_types.Requireable<string>;
        const type: prop_types.Validator<string>;
        function variant(props: any, propName: any, componentName: any): void | Error | null;
        const animation: prop_types.Requireable<string | boolean>;
    }
}

declare function ActionRequirement(props: any): JSX.Element;
declare namespace ActionRequirement {
    namespace propTypes {
        export const title: prop_types.Validator<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export const children: prop_types.Requireable<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export const description: prop_types.Validator<string | (string | null | undefined)[]>;
        export const checkable: prop_types.Requireable<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export const illustration: prop_types.Requireable<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export const list: prop_types.Requireable<string | number | boolean | prop_types.ReactElementLike | prop_types.ReactNodeArray>;
        export { bool as titleAsTextDisplay };
        export { number as ariaLevelTitle };
    }
}

declare const Popover: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

declare const _default: React.ForwardRefExoticComponent<{
    [x: string]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: number]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
    [x: symbol]: React.JSX.LibraryManagedAttributes<C, React.ComponentPropsWithRef<C>>;
} & {
    theme?: any;
}>;

export { Accordion, ActionRequirement, AutoComplete, Avatar, Banner, BottomSheet, Box, Button, Card, _default$7 as Checkbox, _default$3 as Chips, Col, Container, Datepicker, Dialog, _default$1 as Divider, Drawer, Dropdown, _default$5 as EventCard, Feedback, Header, Heading, Hide, Input, List, Menu, PlanCard, Popover, Progress, RadioGroup, _default$4 as Rating, Row, Skeleton, _default$6 as Slider, _default$2 as Snackbar, _default as Spinner, Stepper, Tag, Text, TextArea };