import { BackgroundColorsTokenType, BorderColorsTokenType, BorderRadiusTokenType, BordersTokenType, BreakpointsTokenType, ColorsTokenType, ShadowsTokenType, SpacingTokenType, TextColorsTokenType, TypographyTokenType } from './design-token.type';
import { DirectionalSpacingType, SpacingDirection, ResponsiveType, ResponsiveScope, GridColumnsType, GridRowsType, GridJustifyItemsType, TranslocationType, AccordionObserverPayload, FlexDirectionType, FlexAlignItemType, FlexJustifyContentType, BoxDisplayType, DirectionalBorderRadiusType, BorderRadiusDirection, StateVariantType, CssStatesType, FlexWrapType, BorderStyleType, TextAlignType, MarginValueType, DirectionalMarginType, SizeType } from './ui.type';
import { SelectSourceItem } from '../components/vega-input-select/types';
import { DropdownSourceItem } from '../components/vega-dropdown/types';
import { Nullable } from './general';
import { VegaTableColumnGroupingModel } from '../components/vega-table/interface';
import { CalendarDate } from '../helpers/calendar';
import { VegaEATriggerStrategy } from '../helpers/slimmers/element-appender/trigger-strategies/trigger-strategy.interface';
/**
 * Returns true if the input is a string that is one of the four directions.
 *
 * @param {unknown} input - The value to check.
 * @returns {boolean} indicating if the input is type of {@link SpacingDirection}
 */
export declare const isSpacingDirection: (input: unknown) => input is SpacingDirection;
/**
 * If the input is a string and the string is a key in the Spacing enum, then the input is a SpacingTokenType.
 *
 * @param {unknown} input - The value to check.
 * @returns {boolean} indicating if the input is type of {@link SpacingTokenType}
 */
export declare const isSpacingTokenType: (input: unknown) => input is SpacingTokenType;
/**
 * If every key in the input is a valid spacing direction and every value in the input is a valid spacing value, then the
 * input is a valid directional spacing type.
 *
 * @param {unknown} input - unknown - This is the input value that we want to check.
 * @returns {boolean} indicating if the input is type of {@link DirectionalSpacingType}
 */
export declare const isDirectionalSpacingType: (input: unknown) => input is DirectionalSpacingType;
/**
 * `isResponsiveType` returns true if the input is an object with a `default` property and all other properties are valid
 * breakpoints
 *
 * @param {unknown} input - unknown - this is the input that we want to check if it's a ResponsiveType
 * @returns {boolean} indicating if the input is type of {@link ResponsiveType<ResponsiveScope>}
 */
export declare const isResponsiveType: (input: unknown) => input is ResponsiveType<ResponsiveScope>;
/**
 * If the input is a string and it's either in the Breakpoints enum or it's the string 'default', then it's a
 * BreakpointsTokenType.
 *
 * @param {unknown} input - The value to check.
 * @returns {boolean} indicating if the input is type of {@link BreakpointsTokenType}
 */
export declare const isBreakpointsTokenType: (input: unknown) => input is BreakpointsTokenType;
/**
 * This function returns true if the input is a string that is a key in the BorderRadius object.
 *
 * @param {unknown} input - unknown - This is the input that will be checked.
 * @returns {boolean} indicating if the input is type of {@link BorderRadiusTokenType}
 */
export declare const isBorderRadiusTokenType: (input: unknown) => input is BorderRadiusTokenType;
/**
 * If the input is a string and it's in the Colors array, then it's a ColorsTokenType.
 *
 * @param {unknown} input - unknown - This is the input that we're checking.
 * @returns {boolean} indicating if the input is type of {@link ColorsTokenType}
 */
export declare const isColorTokenType: (input: unknown) => input is ColorsTokenType;
/**
 * It returns true if the input is a string that starts with 'border-color-' and is a valid color token type.
 *
 * @param {unknown} input - The value to be tested.
 * @returns {boolean} indicating if the input is {@link BorderColorsTokenType}
 */
export declare const isBorderColorTokenType: (input: unknown) => input is BorderColorsTokenType;
/**
 * If the input is a string and it's in the Borders array, then it's a BordersTokenType.
 *
 * @param {unknown} input - unknown - This is the input that we're checking.
 * @returns {boolean} indicating if the input is type of {@link BordersTokenType}
 */
export declare const isBorderTokenType: (input: unknown) => input is BordersTokenType;
/**
 * It returns true if the input is a string that starts with `bg-` and is a valid color token type.
 *
 * @param {unknown} input - The value to be tested.
 * @returns {boolean} indicating if the input is {@link BackgroundColorsTokenType}
 */
export declare const isBackgroundColorTokenType: (input: unknown) => input is BackgroundColorsTokenType;
/**
 * This function returns true if the input is a string that starts with 'text-' and is a valid color token type.
 *
 * @param {unknown} input - The value to check.
 * @returns {boolean} indicating if the input is {@link TextColorsTokenType}
 */
export declare const isTextColorTokenType: (input: unknown) => input is TextColorsTokenType;
/**
 * If the input is a string and it's in the Shadows array, then it's a ShadowsTokenType.
 *
 * @param {unknown} input - unknown - This is the input that will be checked.
 * @returns {boolean} indicating if the input is {@link ShadowsTokenType}
 */
export declare const isShadowsTokenType: (input: unknown) => input is ShadowsTokenType;
/**
 * If the input is a number, it must be between 1 and 12. If the input is a string, it must be in the
 * format of '1-auto' to '12-auto'.
 *
 * @param {unknown} input - The input to be tested.
 * @returns {boolean} indicating if the input is {@link GridColumnsType}
 */
export declare const isGridColumnsType: (input: unknown) => input is GridColumnsType;
/**
 * If the input is a number, it must be between 1 and 12. If the input is a string, it must be in the
 * format of '1-auto' to '12-auto'.
 *
 * @param {unknown} input - The input to be tested.
 * @returns {boolean} indicating if the input is {@link GridRowsType}
 */
export declare const isGridRowsType: (input: unknown) => input is GridRowsType;
/**
 * Checks if the input is a valid GridJustifyItemsType value.
 *
 * @param {unknown} input - The input to test.
 * @returns {boolean} indicating if the input is {@link GridJustifyItemsType}
 */
export declare const isGridJustifyItemsType: (input: unknown) => input is GridJustifyItemsType;
/**
 * If the input is a string, and that string is a key in the Breakpoints object, then the input is a GridRowType.
 *
 * @param {unknown} input - The value that is being checked.
 * @returns {boolean} indicating if the input is {@link BreakpointsTokenType}
 */
export declare const isBreakpointsForPrefixType: (input: unknown) => input is BreakpointsTokenType;
/**
 * If the input is an object with a number property named X and a number property named Y, then it's a TranslocationType.
 *
 * @param {unknown} input - The input to check.
 * @returns {boolean} indicating if the input is {@link TranslocationType}
 */
export declare const isTranslocationType: (input: unknown) => input is TranslocationType;
/**
 * "If the input is an object with a `groupId` property that is a string, and an `element` property that is an object with
 * a `tagName` property that is `'VEGA-ACCORDION'`, then return true, otherwise return false."
 *
 * The above function is a type guard. It's a function that takes an input of type `unknown` and returns a boolean. If the
 * input is of the type we're looking for, then the function returns `true`, otherwise it returns `false`
 *
 * @param {unknown} input - The input to check.
 * @returns {boolean} indicating if the input is {@link AccordionObserverPayload}
 */
export declare const isAccordionObserverPayload: (input: unknown) => input is AccordionObserverPayload;
/**
 * If the input is a string and it's in the list of FlexDirections, then it's a FlexDirectionType.
 *
 * @param {unknown} input - unknown - This is the input that we want to check.
 * @returns {boolean} A function that takes an unknown input and returns a boolean.
 */
export declare const isFlexDirectionType: (input: unknown) => input is FlexDirectionType;
/**
 * This TypeScript function checks if an input is a valid FlexAlignItemType.
 *
 * @param {unknown} input - The input parameter is of type unknown, which means it can be any type of
 * value. The function is checking if the input is a string and if it is included in the FlexAlignItem
 * array. If both conditions are true, it returns true, indicating that the input is of type
 * FlexAlignItemType
 * @returns {boolean} The function `isFlexAlignItemType` is returning a boolean value. It checks if the `input`
 * parameter is a string and if it is included in the `FlexAlignItem` array. If both conditions are
 * true, it returns `true`, indicating that the `input` is of type `FlexAlignItemType`. Otherwise, it
 * returns `false`.
 */
export declare const isFlexAlignItemType: (input: unknown) => input is FlexAlignItemType;
/**
 * This TypeScript function checks if an input is a valid FlexJustifyContentType.
 *
 * @param {unknown} input - The input parameter is of type unknown, which means it can be any type of
 * value. The function is checking if the input is a string and if it is one of the values in the
 * FlexJustifyContent array.
 * @returns {boolean} A boolean value. The function checks if the input is a string and if it is included in the
 * `FlexJustifyContent` array, and returns `true` if both conditions are met, indicating that the input
 * is of type `FlexJustifyContentType`. If either condition is not met, the function returns `false`.
 */
export declare const isFlexJustifyContentType: (input: unknown) => input is FlexJustifyContentType;
/**
 * The function `isFlexWrapType` checks if the input is a valid `FlexWrapType` string.
 *
 * @param {unknown} input - The `input` parameter in the `isFlexWrapType` function is of type
 * `unknown`, which means it can be any type of value. The function checks if the input is a string and
 * if it is included in the `FlexWrap` array.
 * @returns {boolean} The `isFlexWrapType` function is returning a boolean value. It checks if the `input` is a
 * string and if it is included in the `FlexWrap` array, which contains valid `FlexWrapType` values. If
 * both conditions are met, the function returns `true`, indicating that the `input` is of type
 * `FlexWrapType`. Otherwise, it returns `false`.
 */
export declare const isFlexWrapType: (input: unknown) => input is FlexWrapType;
/**
 * The function `isTextAlignType` checks if the input is a valid `TextAlignType` string.
 *
 * @param {unknown} input - The `input` parameter is of type `unknown`, which means it can be any type
 * of value.
 * @returns {boolean} The `isTextAlignType` function is returning a boolean value. It checks if the `input` is a
 * string and if it is included in the `TextAlign` array, which presumably contains valid
 * `TextAlignType` values. If both conditions are met, the function returns `true`, indicating that the
 * `input` is of type `TextAlignType`. Otherwise, it returns `false
 */
export declare const isTextAlignType: (input: unknown) => input is TextAlignType;
/**
 * It takes an array of unknowns and a type guard function, and returns a type guard function that
 * returns true if the input is an array of the type that the type guard function guards
 *
 * @param {unknown} input - unknown - the input to check
 * @param {Function} itemTypeGuard - (item: unknown) => item is T
 * @returns {boolean} A function that takes two arguments, input and itemTypeGuard.
 */
export declare const isArrayOfType: <T>(input: unknown, itemTypeGuard: (item: unknown) => item is T) => input is T[];
/**
 * If the input is an object with a label and key property, then it's a DropdownSourceItem.
 *
 * @param {unknown} input - The input to check.
 * @returns {boolean} A function that takes in an unknown input and returns a boolean.
 */
export declare const isDropdownSourceItemType: (input: unknown) => input is DropdownSourceItem;
/**
 * If the input is an object with an id and displayName property, then it's a SelectSourceItem.
 *
 * @param {unknown} input - The input to check.
 * @returns {boolean} A function that takes an input and returns a boolean.
 */
export declare const isSelectSourceItemType: (input: unknown) => input is SelectSourceItem;
/**
 * The function `isBoxDisplayType` checks if the input is a valid BoxDisplayType.
 *
 * @param {unknown} input - The input parameter is of type unknown, which means it can be any type.
 * @returns {boolean} a boolean value.
 */
export declare const isBoxDisplayType: (input: unknown) => input is BoxDisplayType;
/**
 * Check if the input is not null and undefined
 *
 * @param {Nullable} input - the value
 * @returns {boolean} return true if the input is not null and undefined
 */
export declare const isNonNullable: <T>(input: Nullable<T>) => input is T;
/**
 * The function `isTypographyTokenType` checks if the input is a string and if it is one of the predefined TypographyTokenType values.
 *
 * @param {unknown} input - The input parameter is of type unknown, which means it can be any type.
 * @returns {boolean} a boolean value.
 */
export declare const isTypographyTokenType: (input: unknown) => input is TypographyTokenType;
/**
 * The function `isBorderStyleType` checks if the input is a valid BorderStyleType string.
 *
 * @param {unknown} input - The `input` parameter is of type `unknown`, which means it can be any type
 * of value. The `isBorderStyleType` function is a type guard function that checks if the `input` is of
 * type `BorderStyleType`.
 * @returns {boolean} The `isBorderStyleType` function is returning a boolean value. It checks if the `input` is
 * of type `BorderStyleType` by verifying if it is a string and if it is included in the `BorderStyle`
 * array. If the condition is met, it returns `true`, indicating that the `input` is of type
 * `BorderStyleType`. Otherwise, it returns `false`.
 */
export declare const isBorderStyleType: (input: unknown) => input is BorderStyleType;
/**
 * The function `isBorderRadiusDirectionType` checks if the input is a valid `BorderRadiusDirection` type.
 *
 * @param {unknown} input - The `input` parameter in the `isBorderRadiusDirectionType` function is of
 * type `unknown`, which means it can be any type of value. The function checks if the input is a
 * string and if it matches one of the specified values in the array ['top', 'left', 'right
 * @returns {boolean} The function `isBorderRadiusDirectionType` is returning a boolean value indicating whether
 * the `input` is of type `BorderRadiusDirection` or not.
 */
export declare const isBorderRadiusDirectionType: (input: unknown) => input is BorderRadiusDirection;
/**
 * The function `isDirectionalBorderRadiusType` checks if the input object conforms to the
 * `DirectionalBorderRadiusType` type.
 *
 * @param {unknown} input - The `input` parameter in the `isDirectionalBorderRadiusType` function is of
 * type `unknown`, which means it can be any type of value. The function is checking if the input is a
 * valid `DirectionalBorderRadiusType` by verifying that it is an object, not null,
 * @returns {boolean} The function `isDirectionalBorderRadiusType` is returning a boolean value.
 */
export declare const isDirectionalBorderRadiusType: (input: unknown) => input is DirectionalBorderRadiusType;
/**
 * The function `isStateVariantTokenType` checks if the input is an object with keys that are all of
 * type `CssStatesType`.
 *
 * @param {unknown} input - The `input` parameter is a value of type `unknown`, which means it can be
 * any type of value in TypeScript.
 * @returns {boolean} The `isStateVariantTokenType` function is returning a boolean value. It checks if the
 * `input` is an object that is not null and if all the keys of the object pass the `isCssStateType`
 * check. If these conditions are met, it returns `true`, indicating that the `input` is of type
 * `StateVariantType<T, CssStatesType>`. Otherwise, it
 */
export declare const isStateVariantTokenType: <T>(input: unknown) => input is StateVariantType<T, CssStatesType>;
/**
 * The function `isCssStateType` checks if the input is a valid CSS state type by verifying if it is a
 * string and included in a predefined list of CSS states.
 *
 * @param {CssStatesType} input - The `input` parameter in the `isCssStateType` function is of type
 * `CssStatesType`.
 * @returns {boolean} The function `isCssStateType` is returning a boolean value.
 */
export declare const isCssStateType: (input: CssStatesType) => input is CssStatesType;
/**
 * Checks that the provided value is a non-null object with at least the
 * required grouping-model properties (`key` and `label`) and that `label`
 * is a string.
 *
 * @param {unknown} input - Value to test.
 * @returns {input is VegaTableColumnGroupingModel} True when input matches the grouping model shape.
 */
export declare const isVegaTableColumnGroupingModelType: (input: unknown) => input is VegaTableColumnGroupingModel;
/**
 * Check is calendar date type
 *
 * @param {unknown} input - Value to test.
 * @returns {input is CalendarDate} True when input matches the calendar date type.
 */
export declare const isCalendarDateType: (input: unknown) => input is CalendarDate;
/**
 * Type guard to check if the provided instance implements the VegaEATriggerStrategy interface
 *
 * @param {unknown} instance - The instance to check.
 * @returns {instance is VegaEATriggerStrategy} True if the instance implements VegaEATriggerStrategy.
 */
export declare const isEATriggerStrategy: (instance: unknown) => instance is VegaEATriggerStrategy;
/**
 * Validates if the input is of type MarginValueType, which can be either a SpacingTokenType or the string 'auto'.
 *
 * @param {unknown} input - The value to check.
 * @returns {boolean} indicating if the input is type of {@link MarginValueType}
 */
export declare const isMarginValueType: (input: unknown) => input is MarginValueType;
/**
 * Validates if the input is of type DirectionalMarginType.
 *
 * @param {unknown} input - The value to check.
 * @returns {boolean} indicating if the input is type of {@link DirectionalMarginType}
 */
export declare const isDirectionalMarginType: (input: unknown) => input is DirectionalMarginType;
/**
 * Validates if the input is of type SizeType, which can be either a number or a string in the format of `${number}%`.
 *
 * @param {unknown} input - The value to check.
 * @returns {boolean} indicating if the input is type of {@link SizeType}
 */
export declare const isSizeType: (input: unknown) => input is SizeType;
/**
 * Validates if the input is of type SizeType or an object with breakpoint keys and SizeType values.
 *
 * @param {unknown} input - The value to check.
 * @returns {boolean} indicating if the input is type of {@link ResponsiveType<SizeType>}
 */
export declare const isResponsiveSizeType: (input: unknown) => input is ResponsiveType<SizeType>;
