@ntbjs/react-components 2.0.14 → 3.0.0-rc.1

package/types/components/inputs/MultiLevelCheckbox/types.d.ts

@@ -0,0 +1,72 @@
+import PropTypes from 'prop-types';
+/**
+ * The option tree `MultiLevelCheckbox` and `MultiLevelCheckboxSelect` render.
+ *
+ * TWO THINGS IN HERE, DESPITE THE FILE NAME: the types, and `findChildValues` —
+ * a runtime helper both components call. The helper predates the file's name;
+ * moving it is a separate commit.
+ */
+/**
+ * A node's identity.
+ *
+ * `string | number` RATHER THAN THE `PropTypes.any` IT REPLACES, because three
+ * runtime uses constrain it and none of them accepts an arbitrary value: it is
+ * the React `key` of every rendered `CheckboxTree`, it is the `value` of the
+ * underlying `<input type="checkbox">`, and it is compared with `===` and
+ * `Array.prototype.includes` against the `checked` array the consumer owns.
+ * An object here already renders as `[object Object]` and breaks reconciliation,
+ * so `any` was permission for a bug rather than a description of the API.
+ *
+ * Every value in the stories is a string.
+ */
+export type MultiLevelCheckboxNodeValue = string | number;
+/**
+ * One option, with any number of levels of children under it.
+ *
+ * GENUINELY RECURSIVE, WHICH THE propTypes AT THE BOTTOM ARE NOT — and the
+ * recursion is the accurate description, not an improvement invented here:
+ *
+ * - `NodeType` validates exactly two levels and then gives up (`children:
+ *   PropTypes.array`), because a self-referential `PropTypes.shape` is not
+ *   expressible without a lazy indirection. Its own comment says so.
+ * - `findChildValues` below, `hasChildrenSelected`, `hasAllChildrenSelected`,
+ *   `getLabelByValue` and `CheckboxTree` itself all recurse without a depth
+ *   limit, and the stories ship four-level trees
+ *   (`sport → idrettsgren → golf → minigolf`).
+ *
+ * So the propTypes silently accepted anything below level two while the
+ * components happily walked it. This interface is what the code has always
+ * meant.
+ */
+export interface MultiLevelCheckboxNode {
+    /** Shown next to the checkbox, and what the `search` prop matches against. */
+    label: string;
+    value: MultiLevelCheckboxNodeValue;
+    /**
+     * Child options. A node with a non-empty `children` array gets an expander
+     * arrow; checking it checks the whole subtree.
+     */
+    children?: MultiLevelCheckboxNode[];
+}
+/**
+ * Every descendant value under `node`, depth-first, excluding `node` itself.
+ *
+ * Callers pass `[node.value, ...findChildValues(node)]` when they want the node
+ * included, which is why it is excluded here.
+ *
+ * Guards on `Array.isArray(node.children)`, so a node whose `children` is
+ * `undefined` — or something the type says it cannot be — yields `[]` rather
+ * than throwing. There is no cycle protection: a node reachable from its own
+ * subtree recurses until the stack runs out. That is pre-existing, and the tree
+ * comes from the consumer.
+ */
+export declare function findChildValues(node: MultiLevelCheckboxNode): MultiLevelCheckboxNodeValue[];
+export declare const NodeType: PropTypes.Requireable<PropTypes.InferProps<{
+    label: PropTypes.Validator<string>;
+    value: PropTypes.Validator<any>;
+    children: PropTypes.Requireable<PropTypes.InferProps<{
+        label: PropTypes.Validator<string>;
+        value: PropTypes.Validator<any>;
+        children: PropTypes.Requireable<any[]>;
+    }>[]>;
+}>>;

package/types/components/inputs/MultiLevelCheckboxSelect/MultiLevelCheckboxSelect.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import type { MultiLevelCheckboxNode } from '../MultiLevelCheckbox/types';
+type MultiLevelCheckboxSelectOwnProps = {
+    /**
+     * Label text for the MultiLevelCheckbox
+     */
+    label?: string;
+    /**
+     * The placeholder of the input. Text to be displayed on the input element when the component is enabled and not focused – e.g. "Select categories..."
+     */
+    placeholder?: string;
+    options: MultiLevelCheckboxNode[];
+    /**
+     * Array of checked option values
+     */
+    checked: any[];
+    /**
+     * Optional text to display when no results are found while searching.`
+     */
+    noResultsText?: string;
+    /**
+     *  Callback function for the `onChange` event
+     */
+    onChange: (...args: any[]) => any;
+    /**
+     *  Callback function for the `onChange` event – returns only the checked parents
+     */
+    onParentChange?: (...args: any[]) => any;
+};
+/**
+ * MultiLevelCheckboxSelect allow the user to select one or more items from a nested set into a MultiSelect-styled input.
+ *
+ * This component is controlled which means that the consumer will have to keep track of what options are selected. The selected options should be provided to the `checked`-prop. On any selection or deselection onChange will be called with an updated `checked`-list.
+ *
+ * ### Import
+ *
+ * ```js
+ * import { MultiLevelCheckboxSelect } from '@ntbjs/react-components/inputs'
+ * // or
+ * import MultiLevelCheckboxSelect from '@ntbjs/react-components/inputs/MultiLevelCheckboxSelect'
+ * ```
+ */
+declare const MultiLevelCheckboxSelect: React.ForwardRefExoticComponent<Omit<Omit<import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>, "ref">, keyof MultiLevelCheckboxSelectOwnProps> & MultiLevelCheckboxSelectOwnProps & React.RefAttributes<any>>;
+export default MultiLevelCheckboxSelect;

package/types/components/inputs/MultiLevelCheckboxSelect/MultiLevelCheckboxSelect.styled.d.ts

@@ -0,0 +1,11 @@
+export declare const MultiLevelCheckboxSelect: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const MultiLevelCheckboxSelectInput: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const Item: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const ItemLabel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const ItemRemoveButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>>, never>, never>> & string;
+export declare const Label: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const Placeholder: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const PopoverContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const PopoverHeader: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const SearchContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const OptionsContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;

package/types/components/inputs/MultiLevelCheckboxSelect/index.d.ts

@@ -0,0 +1 @@
+export { default } from './MultiLevelCheckboxSelect';

package/types/components/inputs/MultiSelect/MultiSelect.d.ts

@@ -0,0 +1,172 @@
+import React from 'react';
+import * as S from './MultiSelect.styled';
+/**
+ * MultiSelect's OWN props — the 19 members that were the entirety of this component's
+ * declared surface until NMB-3998, unchanged. They stay authoritative: `MultiSelectProps`
+ * below `Omit`s these keys out of the base before intersecting, so nothing here is
+ * narrowed by a colliding member of react-select's props.
+ */
+export type MultiSelectOwnProps = {
+    /**
+     *
+     * The label of the input field – leave `undefined` to hide the label
+     */
+    label?: string;
+    /**
+     * `Array` of `objects` containing the default options. This is only needed
+     * when asynchronous option fetching with the `loadOptions` prop is not used.
+     *
+     * **Note:**
+     * <br />This will be overridden by the `loadOptions` prop if both props are set.
+     */
+    availableOptions?: any[];
+    /**
+     * `Array` of `objects` containing the selected options.
+     */
+    selectedOptions?: any[];
+    /**
+     * Function with a `Promise` returning filtered options.
+     *
+     * See [Asynchronous fetching/filtering with pagination](#asynchronous-fetchingfiltering-with-pagination)
+     * for details.
+     *
+     * **Note:**
+     * <br />This will override the `availableOptions` prop if both props are set.
+     */
+    loadOptions?: (...args: any[]) => any;
+    /**
+     * Function for custom "Loading..." message while waiting for the first page
+     * from `loadOptions` to resolve. Defaults to "Loading..." if no function is provided.
+     */
+    loadingMessageFunc?: (...args: any[]) => any;
+    /**
+     * Callback function for sending updates to the backend whenever the selected values are updated.
+     * See [Update handling](#update-handling) for details.
+     */
+    onUpdateCallback?: (...args: any[]) => any;
+    /**
+     * Text to be displayed on the input element when the component
+     * is enabled and not focused – e.g. "Add a keyword..."
+     */
+    editText: string;
+    /**
+     * Whether the user can create new options.
+     */
+    creatable?: boolean;
+    /**
+     * Callback function for formatting the message displayed in the dropdown when there
+     * are no matching options, and the user has permission to create new options.
+     * The callback function will be given the current input value as an argument.
+     */
+    createNewOptionMessageFunc?: (...args: any[]) => any;
+    /**
+     * If the list of options is empty, or if the current input value doesn't match
+     * any of the available options and the user doesn't have permission to add options,
+     * this function will be called and passed the current input value as an argument.
+     */
+    noOptionsMessageFunc?: (...args: any[]) => any;
+    /**
+     * Optional callback function to be trigger when clicking a selected option's label – e.g. opening
+     * a search filtered on the given multi-value's `label`.
+     *
+     * The callback function will be passed the option `object` as an argument.
+     */
+    onMultiValueClick?: (...args: any[]) => any;
+    /**
+     * Display an overlay which the user needs to click in order to
+     * show the selected options list in its entirety and edit it.
+     */
+    showMore?: boolean;
+    /**
+     * Text displayed on the "Show more" overlay.
+     */
+    showMoreText?: string;
+    /**
+     * Whether to display the total number of selected options after the show more text.
+     */
+    displayTotalOnShowMore?: boolean;
+    /**
+     * Whether the multi-select should be displayed in read-only mode.
+     * The user can still click the selected options to trigger their on-click effect.
+     */
+    readOnly?: boolean;
+    /**
+     * Whether the component is hidden or visible.
+     */
+    hidden?: boolean;
+    /**
+     * Whether the multi-select should be disabled.
+     * The user will not be able to trigger the on-click effect of the selected options.
+     */
+    disabled?: boolean;
+    /**
+     * Set to `true` to display a red border indicating an error.
+     * Pass in a `string` instead to also show the string underneath the input field.
+     *
+     * **Note:**
+     * <br />This overrides the "Show more" overlay. Errors will be prioritized over warnings.
+     */
+    error?: boolean | string;
+    /**
+     * Set to `true` to display an orange border.
+     * Pass in a `string` instead to also show the string underneath the input field.
+     *
+     * **Note:**
+     * <br />This overrides the "Show more" overlay. Errors will be prioritized over warnings.
+     */
+    warning?: boolean | string;
+};
+/**
+ * THE PUBLISHED PROPS TYPE. It has a base, and that is playbook §C.2, not a convenience.
+ *
+ * This component destructures `...rest` (below) and spreads it into react-select —
+ * `sharedSelectProps = { ...rest, … }`, handed to `<SelectComponent {...sharedSelectProps} />`.
+ * A closed 19-member type therefore REJECTED props that this component forwards and that
+ * work at runtime: measured against mb-main-client, `className`, `name`, `onBlur` and
+ * `required` are all real react-select props being passed today and all four were a hard
+ * TS2322 the moment the library started shipping `.d.ts`. That is the library lying about
+ * its own contract, which is the exact class §C.2 exists to prevent — and it is NOT the
+ * same finding as the other 22 rejected consumer attributes, which are props no component
+ * here spreads anywhere and which stay rejected on purpose.
+ *
+ * THE BASE IS READ OFF WHAT `rest` IS ACTUALLY SPREAD ONTO, never assumed. That target is
+ * one of the four `styled(<react-select …>)` wrappers, chosen at runtime by `loadOptions`
+ * and `creatable`. `S.MultiSelect` — `styled(Select)` — is the deliberate choice among the
+ * four: `CreatableSelect`/`AsyncPaginate` add props on top of the plain select's surface,
+ * so plain `Select` is the set that is valid in ALL FOUR configurations. Basing this on the
+ * async-creatable wrapper instead would admit `debounceTimeout` and friends in the default
+ * configuration, where they do nothing — the same mistake in the other direction.
+ *
+ * `Omit<Base, keyof Own> & Own`, NOT `Base & Own`. An intersection intersects a colliding
+ * MEMBER rather than replacing it; measured on `TextArea`, `rows?: number | string` met
+ * `styled.textarea`'s `rows?: number` and `rows="4"` became an error — half a published
+ * prop silently deleted by the pass meant to widen it. Disjoint pairs collapse to `never`.
+ *
+ * `ComponentPropsWithoutRef`, NOT `…WithRef`. `React.forwardRef` below supplies `ref`
+ * itself; `WithRef` was measured to let `<MultiSelect ref={…} />` compile with the ref
+ * silently dropped.
+ *
+ * BOTH ALIASES ARE `export`ed AND THE `const` BELOW IS ANNOTATED, for declaration emit
+ * only — same mechanism and same audit as `CompactAutocompleteSelect` (577fc8d, §G.4.1).
+ * tsc prints an exported alias from its source text and EXPANDS an unexported one, and the
+ * expansion here reaches react-select's `PublicBaseSelectProps` /
+ * `StateManagerAdditionalProps`, which `react-select`'s `exports` map does not serve:
+ * TS2883, and with `noEmitOnError: false` that means the `.d.ts` is silently not written.
+ * The annotation on the `const` is needed for the same reason — `forwardRef` infers
+ * `ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<any>>` and tsc computes
+ * `PropsWithoutRef<P>` eagerly, which re-expands what the exported alias just avoided.
+ *
+ * THE SWALLOW THIS PARAGRAPH USED TO RECORD AS OPEN IS FIXED. `sharedSelectProps` still
+ * lists 14 keys after `...rest` and they still win — deliberately, and the reasoning is
+ * written out at the literal itself — but `onFocus`, `onBlur` and `onChange` are no longer
+ * among them: they now run the component's own logic and then call the caller's handler.
+ * So `onBlur`, the one a consumer passes today, is both admitted by this type and actually
+ * forwarded. Do not narrow this type to "reflect" the remaining 14: they are the runtime
+ * form of props this component already declares (`selectedOptions`, `availableOptions`,
+ * `disabled`/`readOnly`, `loadOptions`) plus its own rendering and CSS contract, and
+ * `Omit`ting them would only stop react-select's own names from being accepted while
+ * changing nothing about which value wins.
+ */
+export type MultiSelectProps = Omit<React.ComponentPropsWithoutRef<typeof S.MultiSelect>, keyof MultiSelectOwnProps> & MultiSelectOwnProps;
+declare const MultiSelect: React.ForwardRefExoticComponent<MultiSelectProps & React.RefAttributes<any>>;
+export default MultiSelect;

package/types/components/inputs/MultiSelect/MultiSelect.styled.d.ts

@@ -0,0 +1,99 @@
+import type React from 'react';
+import Select from 'react-select';
+import CreatableSelect from 'react-select/creatable';
+import { AsyncPaginate } from 'react-select-async-paginate';
+import type { PartialNtbTheme } from '../../../utils/defaultTheme';
+/**
+ * The `theme` prop of the four react-select wrappers below, restated as OUR theme.
+ *
+ * WHY THIS EXISTS. `theme` is the one prop name that both styled-components and
+ * react-select claim. react-select declares it `ThemeConfig = Theme | ((t: Theme) => Theme)`
+ * and its `Theme` requires `borderRadius`, which `NtbTheme` does not have — so
+ * `.attrs(applyDefaultTheme)`, whose return type is `{ theme: NtbTheme }`, was
+ * unassignable to `Attrs<SelectProps>` and each wrapper reported:
+ *
+ *   TS2345 … Types of property 'theme' are incompatible.
+ *     Type 'NtbTheme' is not assignable to type 'ThemeConfig'.
+ *       Property 'borderRadius' is missing in type 'NtbTheme' but required in type 'Theme'.
+ *
+ * `.attrs<{ theme?: PartialNtbTheme }>` fixes it because `attrs`' generic is applied as
+ * `Substitute<OuterProps, P> = FastOmit<OuterProps, keyof P> & P` — i.e. declaring
+ * `theme` REPLACES react-select's declaration of it rather than intersecting with it.
+ *
+ * AND THAT IS THE TRUTH ABOUT THIS BOUNDARY, not a workaround. At runtime `.attrs()`
+ * hands react-select the merged `NtbTheme`, and react-select's `getTheme()` does
+ * `{ ...its defaultTheme, ...this.props.theme }`: our `colors` and `spacing` win — which
+ * is why `ThemeColors`/`ThemeSpacing` in `utils/defaultTheme.ts` carry react-select's
+ * member names and not design-token names — and `borderRadius` falls through to
+ * react-select's own `4`. `NtbTheme` is deliberately a PARTIAL override of react-select's
+ * theme, so `ThemeConfig` was never the right type for this prop here.
+ *
+ * `PartialNtbTheme` and not `NtbTheme` because this is the INPUT side: a caller may pass
+ * any subset and `applyDefaultTheme` fills the rest in, exactly as `ThemedProps` states
+ * for every other file. Do NOT "fix" this by adding `borderRadius` to `NtbTheme`: that
+ * would hand react-select a border radius it does not get today and is a render change.
+ */
+interface SelectThemeProp {
+    /** A partial override merged over `defaultTheme` by `applyDefaultTheme`. */
+    theme?: PartialNtbTheme;
+}
+/**
+ * The WRITTEN type of the four `styled(<react-select component>)` exports below, and the
+ * reason they are annotated at all when nothing else in this repo is.
+ *
+ * `styled(Select).attrs<SelectThemeProp>(…)` INFERS a correct type. It is not a
+ * WRITEABLE one: `tsc --declaration` has to print it into `MultiSelect.styled.d.ts`, the
+ * printed form expands to react-select's `PublicBaseSelectProps` and
+ * `StateManagerAdditionalProps`, and neither is re-exported from `react-select`'s public
+ * entry — react-select has an `exports` map with no wildcard, so
+ * `react-select/dist/declarations/src/Select` does not resolve for a consumer at all.
+ * The result was 11 x TS2883 in this file, and the consequence was worse than the
+ * message: `noEmitOnError` is false, so the build "succeeded" while this file's `.d.ts`
+ * was SILENTLY NOT WRITTEN.
+ *
+ * A generic alias fixes it because tsc prints an alias APPLICATION by reference —
+ * `SelectWrapper<typeof Select>` — instead of expanding it, and `typeof Select` is
+ * `typeof import('react-select').default`, which is nameable. Nothing here is widened or
+ * narrowed for the sake of the declaration: `Omit<ComponentProps<C>, keyof P> & P` is
+ * exactly styled-components' own `Substitute<OuterProps, P>`, which is the rule
+ * `SelectThemeProp` above relies on.
+ *
+ * What IS given up is the styled-components-specific surface of these four bindings —
+ * `.withConfig()`, `.attrs()` and re-wrapping with `styled(S.MultiSelect)`. Audited:
+ * nothing in this repo does any of the three to them. Adding one means annotating with
+ * `IStyledComponent` instead, which puts the same non-portable expansion back.
+ */
+type SelectWrapper<C extends React.ComponentType<any>> = React.ComponentType<Omit<React.ComponentProps<C>, keyof SelectThemeProp> & SelectThemeProp>;
+declare const AsyncCreatableSelectPaginate: import("react-select-async-paginate").WithAsyncPaginateType;
+export declare const MultiSelectWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const InnerWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const Label: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>>, never>, never>> & string;
+export declare const MultiSelect: SelectWrapper<typeof Select>;
+export declare const CreatableMultiSelect: SelectWrapper<typeof CreatableSelect>;
+export declare const AsyncMultiSelect: SelectWrapper<typeof AsyncPaginate>;
+export declare const AsyncCreatableMultiSelect: SelectWrapper<typeof AsyncCreatableSelectPaginate>;
+export declare const MultiValueWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DropdownOptionDeleteIcon: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<React.SVGProps<SVGSVGElement> & {
+    title?: string;
+}, React.SVGProps<SVGSVGElement> & {
+    title?: string;
+}>, never>, never>> & string & Omit<React.FunctionComponent<React.SVGProps<SVGSVGElement> & {
+    title?: string;
+}>, keyof React.Component<any, {}, any>>;
+export declare const ShowMoreWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const ShowMoreOverlay: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const ShowMoreText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+/**
+ * `MultiSelect.tsx` renders `<S.ErrorMessage $error={!!error} $warning={!!warning}>`
+ * (line 461), so both are `boolean` — the `!!` is in the JSX, not here. Optional per
+ * §J.5; the template's own ternary chain already ends in `'inherit'` for the
+ * neither-set case.
+ */
+interface ErrorMessageStyleProps {
+    /** `!!error` — red. Wins over `$warning` when both are set. */
+    $error?: boolean;
+    /** `!!warning` — orange. */
+    $warning?: boolean;
+}
+export declare const ErrorMessage: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, ErrorMessageStyleProps>, never>> & string;
+export {};

package/types/components/inputs/MultiSelect/index.d.ts

@@ -0,0 +1 @@
+export { default } from './MultiSelect';

package/types/components/inputs/Radio/Radio.d.ts

@@ -0,0 +1,65 @@
+import React from 'react';
+type RadioOwnProps = {
+    /**
+     * Text displayed by the radio button
+     */
+    label?: any;
+    /**
+     * Name of the radio button (used when sending form data)
+     */
+    name: string;
+    /**
+     * Value to be sent when the given radio button is selected
+     */
+    value: any;
+    /**
+     * Whether the radio button is checked
+     */
+    checked?: boolean;
+    /**
+     * Whether the radio button is checked by default. The most commonly used option should have this set to `true`.
+     */
+    defaultChecked?: boolean;
+    /**
+     * Whether the radio button is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Display the radio button as read-only
+     */
+    readOnly?: boolean;
+    /**
+     * Custom class names for the HTML element
+     */
+    className?: string;
+    /**
+     * Custom inline CSS styling
+     */
+    style?: any;
+    /**
+     * Optional callback function for the `onChange` event
+     */
+    onChange?: (...args: any[]) => any;
+    /**
+     * Optional callback function for the `onBlur` event
+     */
+    onBlur?: (...args: any[]) => any;
+};
+/**
+ * Radio buttons allow the user to select one option from a set.
+ *
+ * Use radio buttons when the user needs to see all available options. If available options can be
+ * collapsed, consider using a dropdown menu because it uses less space.
+ *
+ * Radio buttons should have the most commonly used option selected by default.
+ *
+ * ### Import
+ *
+ * ``` js
+ * import { Radio } from '@ntbjs/react-components/inputs'
+ * // or
+ * import Radio from '@ntbjs/react-components/inputs/Radio'
+ * ```
+ */
+declare const Radio: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, keyof RadioOwnProps> & RadioOwnProps & React.RefAttributes<any>>;
+export default Radio;

package/types/components/inputs/Radio/Radio.styled.d.ts

@@ -0,0 +1,11 @@
+export declare const RadioLabel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+interface RadioStyleProps {
+    /** `checked` — `PropTypes.bool`, passed through as the checked-state affordance. */
+    $isChecked?: boolean;
+    /** `disabled` — `PropTypes.bool`. Leaks to the DOM; see above. */
+    disabled?: boolean;
+    /** `readOnly` — `PropTypes.bool`. Leaks to the DOM; see above. */
+    readOnly?: boolean;
+}
+export declare const Radio: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>>, RadioStyleProps>, never>> & string;
+export {};

package/types/components/inputs/Radio/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Radio';

package/types/components/inputs/Switch/Switch.d.ts

@@ -0,0 +1,62 @@
+import React from 'react';
+type Props = {
+    children?: any;
+    name: string;
+    /**
+     * Whether the switch is toggled on or off
+     */
+    checked?: boolean;
+    /**
+     * Whether the switch is toggled on by default
+     */
+    defaultChecked?: boolean;
+    /**
+     * Text displayed next to the switch
+     */
+    label?: string;
+    /**
+     * Whether the switch is toggled on
+     */
+    disabled?: boolean;
+    /**
+     * Whether the switch is displayed as read-only
+     */
+    readOnly?: boolean;
+    /**
+     * Text displayed underneath the switch
+     */
+    description?: string;
+    /**
+     * Whether there should be extra `margin` added between the switch and the description
+     */
+    spaciousDescription?: boolean;
+    /**
+     * Add extra classes to the HTML element
+     */
+    className?: string;
+    /**
+     * Custom CSS styling
+     */
+    style?: any;
+    /**
+     * Optional callback function for the `onChange` event
+     */
+    onChange?: (...args: any[]) => any;
+    /**
+     * Optional callback function for the `onBlur` event
+     */
+    onBlur?: (...args: any[]) => any;
+};
+/**
+ * The Switch allows the user to toggle an option.
+ *
+ * ### Import
+ *
+ * ``` js
+ * import { Switch } from '@ntbjs/react-components/inputs'
+ * // or
+ * import Switch from '@ntbjs/react-components/inputs/Switch'
+ * ```
+ */
+declare const Switch: React.ForwardRefExoticComponent<Props & React.RefAttributes<any>>;
+export default Switch;

package/types/components/inputs/Switch/Switch.styled.d.ts

@@ -0,0 +1,20 @@
+interface SwitchStyleProps {
+    /** `disabled` — dims and blocks pointer events. Leaks to the DOM; see above. */
+    disabled?: boolean;
+    /** `readOnly` — dims and blocks pointer events. Leaks to the DOM; see above. */
+    readOnly?: boolean;
+}
+export declare const Switch: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, SwitchStyleProps>, never>> & string;
+export declare const SwitchIndicator: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const SwitchIndicatorButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const SwitchIndicatorLabelText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, never>> & string;
+export declare const SwitchLabel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, import("react").DetailedHTMLProps<import("react").LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>>, never>, never>> & string;
+export declare const Description: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, {
+    /**
+     * `spaciousDescription` — `PropTypes.bool`. Lower-case `$spaciousdescription` by
+     * existing convention at both ends; renaming it would be a two-file change for no
+     * type benefit.
+     */
+    $spaciousdescription?: boolean;
+}>, never>> & string;
+export {};

package/types/components/inputs/Switch/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Switch';