import { SerializedStyles } from "@emotion/react";
import * as React$1 from "react";
import React, { CSSProperties } from "react";
import { SpacingTokens } from "@contentful/f36-tokens";
import * as CSS from "csstype";
//#region src/GlobalStyles/GlobalStyles.d.ts
export declare const GlobalStyles: ({ withNormalize, styles }: {
  /**
   * Determines if CSS reset should be used
   *
   * @default true
   */
  withNormalize?: boolean;
  /**
   * Extend global styles
   *
   * @default undefined
   */
  styles?: SerializedStyles;
}) => import("react/jsx-runtime").JSX.Element;
//#endregion
//#region src/Primitive/Primitive.d.ts
/**
 * Expand object types to show the contents not the name of the type.
 * Should be used when using React.ForwardRef to show list of props
 */
type ExpandProps<T> = T;
type Overwrite<T, U> = Omit<T, keyof U> & U;
type PropsWithAs<P, E extends React.ElementType> = P & {
  as?: E;
};
/**
 * Use for wrapping/mirroring a HTML Element.
 *
 * Example with wrapping button:
 *
 * interface ButtonOwnProps {
 *  customProp: string
 * }
 * type ButtonProps = PropsWithHTMLElement<ButtonOwnProps, 'button'>
 *
 * export function Button(props: ButtonProps) {
 *  const { customProp, ...otherProps } = props;
 *
 *  return <button {...otherProps} />;
 * }
 */
type PropsWithHTMLElement<P, E extends React.ElementType, OmitAdditionalProps extends PropertyKey = never> = Overwrite<Omit<React.ComponentPropsWithoutRef<E>, OmitAdditionalProps>, P>;
type PolymorphicProps<P, E extends React.ElementType, OmitAdditionalProps extends PropertyKey = never> = PropsWithAs<PropsWithHTMLElement<P, E, OmitAdditionalProps>, E>;
type PolymorphicPropsWithRef<P, E extends React.ElementType, OmitAdditionalProps extends PropertyKey = never> = PropsWithAs<Overwrite<Omit<React.ComponentPropsWithRef<E>, OmitAdditionalProps>, P>, E>;
/**
 * A polymorphic React component type.
 *
 * Represents a function component that can render as different element types while preserving correct prop typings and ref forwarding for the chosen element.
 *
 * @template P - The component's own props (the "base" props).
 * @template D - The default element type (must extend React.ElementType)
 * @template OmitAdditionalProps - Keys to omit when merging the component's base props with the props of the chosen element type.
 * Example usage:
 *  - type ButtonProps = { variant?: 'primary' | 'secondary' };
 *  - const Button: PolymorphicComponent<ButtonProps, 'button'> = ...;
 *  - <Button onClick={...} />         // typed as <button>
 *  - <Button as="a" href="...">      // typed as <a>, href validated
 *
 * @returns A React component type that supports polymorphic "as" overrides and proper ref typing.
 */
type PolymorphicComponent<P, D extends React.ElementType, OmitAdditionalProps extends PropertyKey = never> = (<E extends React.ElementType = D>(props: PolymorphicPropsWithRef<P, E, OmitAdditionalProps>) => React.ReactElement | null) & {
  displayName?: string;
};
//#endregion
//#region src/types.d.ts
type CommonProps = {
  /**
   * CSS class to be appended to the root element
   */
  className?: string;
  /**
   * A [data-test-id] attribute used for testing purposes
   */
  testId?: string;
  /** Accepts a JavaScript object with camelCased properties rather than a CSS string */
  style?: CSSProperties;
};
/**
 * Contentful entity status
 */
type EntityStatus = 'archived' | 'changed' | 'deleted' | 'draft' | 'new' | 'published';
type Spacing = SpacingTokens | 'none';
interface MarginProps {
  /**
   * sets margin to one of the corresponding spacing tokens
   */
  margin?: Spacing;
  /**
   * sets margin-top to one of the corresponding spacing tokens
   */
  marginTop?: Spacing;
  /**
   * sets margin-right to one of the corresponding spacing tokens
   */
  marginRight?: Spacing;
  /**
   * sets margin-bottom to one of the corresponding spacing tokens
   */
  marginBottom?: Spacing;
  /**
   * sets margin-left to one of the corresponding spacing tokens */
  marginLeft?: Spacing;
}
interface PaddingProps {
  /**
   * sets padding to one of the corresponding spacing tokens */
  padding?: Spacing;
  /**
   * sets padding-top to one of the corresponding spacing tokens */
  paddingTop?: Spacing;
  /**
   * sets padding-right to one of the corresponding spacing tokens */
  paddingRight?: Spacing;
  /**
   * sets padding-bottom to one of the corresponding spacing tokens */
  paddingBottom?: Spacing;
  /**
   * sets padding-left to one of the corresponding spacing tokens */
  paddingLeft?: Spacing;
}
type PickUnion<UnionType, Keys> = Exclude<UnionType, Exclude<UnionType, Keys>>;
/**
 * Also known as homomorphic.
 * Use this custom Omit utility type to preserve extended Record properties.
 *
 * Why? Using Omit on extended Records does not preserve the structure.
 * - https://github.com/microsoft/TypeScript/issues/36981
 * - https://github.com/microsoft/TypeScript/issues/54451
 */
type MappedOmit<T, K extends keyof T> = { [P in keyof T as P extends K ? never : P]: T[P]; };
//#endregion
//#region src/Flex/Flex.d.ts
interface FlexInternalProps extends CommonProps, MarginProps, PaddingProps {
  /**
   * Child nodes to be rendered in the component */
  children?: React$1.ReactNode;
  /**
   * Sets width: 100% */
  fullWidth?: boolean;
  /**
   * Sets height: 100% */
  fullHeight?: boolean;
  /**
   * Sets display: inline-flex */
  isInline?: boolean;
  /**
   * A shorthand property for flex-grow, flex-shrink, flex-basis
   */
  flex?: CSS.Property.Flex;
  /**
   * Defines the initial size of a flexbox item.
   * */
  flexBasis?: CSS.Property.FlexBasis;
  /**
   * Defines how much a flexbox item should shrink if there's not enough space available. */
  flexShrink?: CSS.Property.FlexShrink;
  /**
   * Defines if flexbox items appear on a single line or on multiple lines within a flexbox container. */
  flexWrap?: CSS.Property.FlexWrap;
  /**
   * Defines how flexbox items are ordered within a flexbox container. */
  flexDirection?: CSS.Property.FlexDirection;
  /**
   * Defines how much a flexbox item should grow if there's space available. */
  flexGrow?: CSS.Property.FlexGrow;
  /**
   * Defines a gap between flexbox items. */
  gap?: Spacing | string;
  /**
   * Defines how flexbox items are aligned according to the main axis, within a flexbox container. */
  justifyContent?: CSS.Property.JustifyContent;
  /**
   * Use it for flexbox items, not for flexbox containers.
   *
   * Sets the way a box is justified inside its alignment container along the appropriate axis. */
  justifySelf?: CSS.Property.JustifySelf;
  /**
   * Defines how flexbox items are aligned according to the cross axis, within a line of a flexbox container.
   */
  alignItems?: CSS.Property.AlignItems;
  /**
   * Use it for flexbox items, not for flexbox containers.
   *
   * Works like align-items, but applies only to a single flexbox item, instead of all of them.
   */
  alignSelf?: CSS.Property.AlignSelf;
  /**
   * Defines how each line is aligned within a flexbox container.
   */
  alignContent?: CSS.Property.AlignContent;
  /**
   * Defines the order of a flexbox item
   */
  order?: CSS.Property.Order;
}
type FlexProps<E extends React$1.ElementType = typeof FLEX_DEFAULT_TAG> = PolymorphicProps<FlexInternalProps, E>;
declare const FLEX_DEFAULT_TAG = "div";
export declare const Flex: PolymorphicComponent<ExpandProps<FlexInternalProps>, typeof FLEX_DEFAULT_TAG>;
//#endregion
//#region src/Grid/Grid.d.ts
interface GridInternalProps extends CommonProps, MarginProps, PaddingProps {
  /**
   * Child nodes to be rendered in the component */
  children?: React$1.ReactNode;
  /**
   * Defines how many columns, default is `auto` */
  columns?: number | CSS.Property.GridTemplateColumns;
  /**
   * Defines how many rows, default is `auto` */
  rows?: number | CSS.Property.GridTemplateColumns;
  /**
   * Spaces between rows, corresponds to of spacing tokens values, default is none */
  rowGap?: Spacing;
  /**
   * One of Spacing tokens values, default is 0 */
  columnGap?: Spacing;
  /**
   * One of grid-auto-flow css values */
  flow?: CSS.Property.GridAutoFlow;
  /**
   * Sets display:inline-grid */
  isInline?: boolean;
  /**
   * Defines how grid items are aligned on the inline axis.
   */
  justifyContent?: CSS.Property.JustifyContent;
  /**
   * Defines the default justify-self for all items of the box, giving them all a default way of justifying each box along the appropriate axis.
   */
  justifyItems?: CSS.Property.JustifyItems;
  /**
   * Controls how grid items are aligned on the block axis.
   */
  alignItems?: CSS.Property.AlignItems;
  /**
   * Defines the placement of grid items within the grid container.
   */
  placeItems?: CSS.Property.PlaceItems;
  /**
   * Defines how each line is aligned within a grid container.
   */
  alignContent?: CSS.Property.AlignContent;
  /**
   * Defines the placement of grid items within the grid container.
   */
  placeContent?: CSS.Property.PlaceContent;
}
declare const GRID_DEFAULT_TAG = "div";
type GridProps<E extends React$1.ElementType = typeof GRID_DEFAULT_TAG> = PolymorphicProps<GridInternalProps, E>;
declare const Grid$1: PolymorphicComponent<ExpandProps<GridInternalProps>, typeof GRID_DEFAULT_TAG>;
//#endregion
//#region src/Grid/GridItem/GridItem.d.ts
declare const GRID_ITEM_DEFAULT_TAG = "div";
interface GridItemInternalProps extends CommonProps, MarginProps, PaddingProps {
  /**
   * Child nodes to be rendered in the component */
  children?: React$1.ReactNode;
  /**
   * one of grid-column-start css values */
  columnStart?: CSS.Property.GridColumnStart;
  /**
   * one of grid-column-end css values */
  columnEnd?: CSS.Property.GridColumnEnd;
  /**
   * one of grid-column-start css values */
  rowStart?: CSS.Property.GridRowStart;
  /**
   * one of grid-row-end css values */
  rowEnd?: CSS.Property.GridRowEnd;
  /**
   * one of grid-area css values */
  area?: CSS.Property.GridArea;
  /**
   * order css property */
  order?: number;
  /**
   * Defines how grid items are aligned on the inline axis.
   */
  justifySelf?: CSS.Property.JustifySelf;
  /**
   * Controls how grid items are aligned on the block axis.
   */
  alignSelf?: CSS.Property.AlignSelf;
  /**
   * Defines the placement of grid items within the grid container.
   */
  placeSelf?: CSS.Property.PlaceSelf;
}
type GridItemProps<E extends React$1.ElementType = typeof GRID_ITEM_DEFAULT_TAG> = PolymorphicProps<GridItemInternalProps, E>;
export declare const GridItem: PolymorphicComponent<GridItemInternalProps, typeof GRID_ITEM_DEFAULT_TAG>;
//#endregion
//#region src/Grid/CompoundGrid.d.ts
type CompoundGrid = typeof Grid$1 & {
  Item: typeof GridItem;
};
export declare const Grid: CompoundGrid;
//#endregion
//#region src/Box/Box.d.ts
declare const BOX_DEFAULT_TAG: React$1.ElementType;
interface BoxInternalProps extends CommonProps, MarginProps, PaddingProps {
  /**
   * Sets the display behavior of the element
   */
  display?: CSS.Property.Display;
  children?: React$1.ReactNode;
}
type BoxProps<E extends React$1.ElementType = typeof BOX_DEFAULT_TAG> = PolymorphicProps<BoxInternalProps, E>;
export declare function useBox<E extends React$1.ElementType = typeof BOX_DEFAULT_TAG>(props: BoxProps<E>): {
  boxProps: {
    className: string;
    "data-test-id": string;
  } & Omit<BoxProps<E>, "display" | "padding" | "marginBottom" | "marginLeft" | "marginRight" | "marginTop" | "paddingBottom" | "paddingLeft" | "paddingRight" | "paddingTop" | "margin" | "className" | "testId" | "as">;
  Element: React$1.ElementType<any, keyof React$1.JSX.IntrinsicElements>;
};
export declare const Box: PolymorphicComponent<ExpandProps<BoxInternalProps>, typeof BOX_DEFAULT_TAG>;
//#endregion
//#region src/Stack/Stack.d.ts
interface StackInternalProps extends Omit<FlexInternalProps, 'flexDirection' | 'gap'> {
  /**
   * Defines how flexbox items are ordered within a flexbox container. */
  flexDirection?: 'row' | 'column';
  /**
   * The space between each stack item
   */
  spacing?: Spacing;
}
type StackProps<E extends React$1.ElementType = typeof STACK_DEFAULT_TAG> = PolymorphicProps<StackInternalProps, E>;
declare const STACK_DEFAULT_TAG = "div";
export declare const Stack: PolymorphicComponent<ExpandProps<StackInternalProps>, typeof STACK_DEFAULT_TAG>;
//#endregion
//#region src/ScreenReaderOnly/ScreenReaderOnly.d.ts
interface ScreenReaderOnlyProps extends CommonProps {
  children?: React.ReactNode;
  as?: 'div' | 'span';
}
export declare const ScreenReaderOnly: {
  ({ children, className, testId, as, ...otherProps }: ScreenReaderOnlyProps): import("react/jsx-runtime").JSX.Element;
  displayName: string;
};
//#endregion
//#region src/hooks/useId.d.ts
/**
 * useId hook provides unique ids for react elements.
 *
 * @param id - an id, provided to a component's props. Can be undefined.
 * @param modifier - a descriptive string, to make ids more readable.
 * @returns a unique id
 */
export declare function useId(id?: string, modifier?: string): string;
//#endregion
//#region src/hooks/useControllableState.d.ts
type UseControllableStateProps = {
  isOpen: boolean;
  defaultIsOpen?: boolean;
  onOpen?: () => void;
  onClose?: () => void;
};
/**
 * Hook that manages the controlled and un-controlled state
 */
export declare function useControllableState({ isOpen, defaultIsOpen, onOpen, onClose }: UseControllableStateProps): {
  isOpen: boolean;
  isControlled: boolean;
  handleClose: () => void;
  handleOpen: () => void;
};
//#endregion
//#region src/hooks/useImageLoaded.d.ts
interface UseImageLoadedProps {
  onLoad?: () => unknown;
}
export declare function useImageLoaded({ onLoad: onLoadProp }?: UseImageLoadedProps): {
  ref: import("react").RefObject<HTMLImageElement>;
  loaded: boolean;
  onLoad: () => void;
};
//#endregion
//#region src/utils/mergeRefs.d.ts
type ReactRef<T> = React.Ref<T> | React.MutableRefObject<T>;
export declare function mergeRefs<T>(...refs: Array<ReactRef<T> | undefined>): React.RefCallback<T>;
//#endregion
//#region src/utils/getEntityStatusStyles.d.ts
export declare const getEntityStatusStyles: ({ status }: {
  status: EntityStatus;
}) => {
  color: string;
  backgroundColor: string;
};
//#endregion
//#region src/utils/getMenuItem.styles.d.ts
export declare const getMenuItemStyles: ({ isActive, isDisabled }: {
  isActive?: boolean;
  isDisabled?: boolean;
}) => string;
//#endregion
export type { BoxProps, CommonProps, EntityStatus, ExpandProps, FlexProps, GridItemProps, GridProps, MappedOmit, MarginProps, PaddingProps, PickUnion, PolymorphicComponent, PolymorphicProps, PropsWithHTMLElement, ScreenReaderOnlyProps, Spacing, StackProps, UseControllableStateProps };
//# sourceMappingURL=index.d.ts.map