import type { EventEmitter } from '../../stencil-public-runtime';
import type { SegmentedControlChangeDetail, SegmentedControlSegment, SegmentedControlSize } from './mud-segmented-control.types';
/**
 * Segmented control — single-select horizontal switcher.
 *
 * Pattern B (atom-interactive, form-associated): renders an internal
 * `role="radiogroup"` of `role="radio"` buttons inside the shadow DOM with
 * a roving `tabindex`. Selected segment gets the dark inverse fill from
 * Figma 659:8188; unselected segments inherit the light tertiary container
 * background and only carry their label.
 *
 * Keyboard contract (WAI-ARIA Authoring Practices, radiogroup pattern):
 * - `Tab` enters and exits the group (single stop)
 * - `ArrowLeft` / `ArrowRight` move selection between segments
 * - `Home` / `End` jump to first / last segment
 * - `Enter` / `Space` reaffirm selection on the focused segment
 *
 * Give the group an accessible name via the native `aria-label` attribute
 * (required when no surrounding `<label>` references the control) or via
 * `aria-labelledby` pointing at an external label element.
 *
 * @element mud-segmented-control
 *
 * Segments come from the `segments` prop only; the component has no slot, so
 * light-DOM children are not rendered.
 */
export declare class MudSegmentedControl {
    /**
     * Visual size rung. `md` is 40 px tall; `sm` is 32 px tall.
     * @default 'md'
     */
    size: SegmentedControlSize;
    /**
     * Disables every segment. The container receives `aria-disabled`.
     * @default false
     */
    disabled: boolean;
    /**
     * Full-width mode. The control fills its container and segments stretch to
     * equal shares — the mobile breakpoint from Figma 659:8188. When false
     * (default) the control hugs its content while keeping segments uniform.
     * @default false
     */
    fluid: boolean;
    /**
     * Forces each segment's icon above its label, with half the inline padding.
     *
     * Leave it off and the control does this for itself: it measures what a row
     * of icons and labels would need against the space it has, and stacks only
     * when the row would not fit. So this prop is for pinning the stacked look
     * even where a row would fit, not for turning the behaviour on.
     *
     * Not a Figma variant — the design set draws one row at both breakpoints and
     * answers a long label with an ellipsis. That answer runs out on a narrow
     * phone: three segments with icons need 382px where a 320px device offers
     * 288, and truncating leaves "Af…", "Ins…" for the user to choose between.
     * Stacking spends the width on the words instead. Pending design sign-off.
     *
     * @default false
     */
    stacked: boolean;
    /**
     * Value of the currently selected segment. Mutable so the control updates it
     * on selection. Like a native form control, `value` is intentionally NOT
     * reflected to the attribute (the attribute represents the default value) —
     * read the current selection from the property or the submitted form value.
     */
    value?: string;
    /**
     * Segment configuration. Order in the array maps left-to-right.
     * When omitted the control renders nothing.
     */
    segments?: SegmentedControlSegment[];
    /** Form-control `name`. Used during form submission. */
    name?: string;
    /** ID of an element labelling the group (when an external label is used). */
    ariaLabelledby?: string;
    private focusedIndex;
    private fieldsetDisabled;
    /** True when the row does not fit and the icons have moved above the labels. */
    private autoStacked;
    host: HTMLMudSegmentedControlElement;
    internals: ElementInternals;
    /** Fires when the selected segment changes. `detail.value` is the new selection. */
    mudChange: EventEmitter<SegmentedControlChangeDetail>;
    private readonly instanceId;
    private readonly groupId;
    private initialValue?;
    private segmentRefs;
    private resizeObserver?;
    validateSize(next: SegmentedControlSize): void;
    handleValueChange(): void;
    handleLayoutInputChange(): void;
    handleKeyDown(ev: KeyboardEvent): void;
    componentWillLoad(): void;
    componentDidLoad(): void;
    disconnectedCallback(): void;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    formStateRestoreCallback(state: string | File | FormData | null): void;
    private syncFormValue;
    private isInert;
    private getEnabledSegments;
    /** Icons or not, a stacked layout only pays off when there is an icon to move. */
    private hasIcons;
    /** Whether the icons currently sit above the labels. */
    private isStacked;
    /** A length custom property on the host, in px. */
    private cssLength;
    /**
     * What a row would need, in px.
     *
     * The widest segment sets it, not the sum: the track lays its columns out as
     * `minmax(floor, 1fr)`, so every segment is as wide as the greediest one.
     * Summing instead said 296px fitted in 300 while the longest label was being
     * cut, because its own share was 94 of the 92 it got.
     *
     * Every term comes from something the current layout cannot change — the
     * label's own text width, and the row's padding, gap and icon size read from
     * the tokens. Measuring the rendered row instead would flip the answer the
     * moment stacking halved the padding, and the control would oscillate.
     */
    private rowWidthNeeded;
    /** The content box the control has to live in. */
    private availableWidth;
    private updateAutoStack;
    private observeAvailableWidth;
    private getSelectedIndex;
    private selectSegment;
    private handleSegmentClick;
    private handleSegmentFocus;
    private handleSegmentBlur;
    private moveFocus;
    private findNextEnabled;
    private setSegmentRef;
    render(): any;
}