import * as _angular_core from '@angular/core';
import { ElementRef, InjectionToken } from '@angular/core';
import { BooleanInput } from '@angular/cdk/coercion';
import { HasElementRef } from '@fundamental-ngx/cdk/utils';
import { IconFont } from '@fundamental-ngx/core/icon';
import { ContentDensityObserver } from '@fundamental-ngx/core/content-density';

interface ButtonModel {
    setDisabled(value: boolean): void;
    isDisabled(): boolean;
    setFdType(value: ButtonType): void;
    getFdType(): ButtonType;
    markForCheck(): void;
}

type GlyphPosition = 'before' | 'after';
type ButtonType = '' | 'standard' | 'positive' | 'negative' | 'attention' | 'half' | 'ghost' | 'transparent' | 'emphasized' | 'menu';
declare const defaultButtonType: ButtonType;
declare class BaseButton implements HasElementRef, ButtonModel {
    /**
     * Whether the button is in a toggled state.
     * Used for toggle buttons that maintain an on/off state.
     * When true, adds the toggled class and sets aria-pressed="true".
     */
    readonly toggled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
    /**
     * Whether the button is selected.
     * Used in button groups or toolbars to indicate the currently selected option.
     * When true, sets aria-selected="true".
     */
    readonly selected: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
    /**
     * Native type attribute of the button element.
     * Defaults to 'button' to prevent form submission.
     * Set to 'submit' for form submission buttons or 'reset' for form reset buttons.
     */
    readonly type: _angular_core.InputSignal<string | null | undefined>;
    /**
     * Position of the icon relative to the button text.
     * - 'before': Icon appears before the text (default)
     * - 'after': Icon appears after the text
     */
    readonly glyphPosition: _angular_core.InputSignal<GlyphPosition>;
    /**
     * The icon to display in the button.
     * See the icon documentation for the list of available icons.
     * Example values: 'add', 'edit', 'delete', 'accept', 'decline'
     */
    readonly glyph: _angular_core.InputSignal<string | null | undefined>;
    /**
     * Font family for the icon.
     * Defaults to the SAP icon font.
     * Override when using custom icon fonts.
     */
    readonly glyphFont: _angular_core.InputSignal<IconFont>;
    /**
     * Visual style of the button.
     * Available types:
     * - 'standard': Default button style (blue)
     * - 'emphasized': High emphasis action (darker blue)
     * - 'positive': Successful/positive action (green)
     * - 'negative': Destructive/negative action (red)
     * - 'attention': Warning action (orange)
     * - 'transparent': No background, minimal style
     * - 'ghost': Subtle button with border on hover
     * - 'half': Split button style
     * - 'menu': Menu trigger button
     */
    readonly fdType: _angular_core.InputSignal<ButtonType>;
    /**
     * Text label displayed inside the button.
     * Can be used alone or combined with an icon.
     */
    readonly label: _angular_core.InputSignal<string | undefined>;
    /**
     * Whether to apply menu mode styling to the button.
     * When true, adds a dropdown arrow icon and menu-specific styling.
     */
    readonly fdMenu: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
    /**
     * Whether the button is disabled.
     * When true, the button cannot be interacted with and displays a disabled state.
     * This sets the native 'disabled' attribute on button elements.
     */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
    /**
     * ARIA disabled attribute for accessibility.
     * Use this when you want to indicate a disabled state to screen readers
     * without preventing interaction (e.g., for showing tooltips on disabled buttons).
     * Unlike the 'disabled' attribute, this does not prevent click events.
     */
    readonly ariaDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
    /**
     * ARIA label for the button.
     * Provides an accessible name for screen readers.
     * If not provided, special button types will auto-generate from label or glyph.
     */
    readonly ariaLabel: _angular_core.InputSignal<string | null | undefined>;
    /**
     * ARIA description for the button.
     * Provides additional context for screen readers beyond the label.
     * Special button types (emphasized, positive, negative, attention) will
     * auto-generate a description from their type if not provided.
     */
    readonly ariaDescription: _angular_core.InputSignal<string | null | undefined>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /**
     * Internal toggled state that can be mutated programmatically.
     * Syncs with the toggled input but allows internal modification.
     * @hidden
     */
    protected readonly toggledState: _angular_core.WritableSignal<boolean>;
    /**
     * Internal selected state that can be mutated programmatically.
     * Syncs with the selected input but allows internal modification.
     * @hidden
     */
    protected readonly selectedState: _angular_core.WritableSignal<boolean>;
    /**
     * Internal button type state that can be mutated programmatically.
     * Syncs with the fdType input but allows internal modification.
     * @hidden
     */
    protected readonly fdTypeState: _angular_core.WritableSignal<ButtonType>;
    /**
     * Internal disabled state that can be mutated programmatically.
     * Syncs with the disabled input but allows internal modification.
     * @hidden
     */
    protected readonly _disabledState: _angular_core.WritableSignal<boolean>;
    /**
     * No-op for ButtonModel interface compatibility.
     * Signals automatically notify Angular when they change.
     * @deprecated Signals eliminate the need for manual change detection.
     */
    markForCheck(): void;
    /**
     * Programmatically set the disabled state.
     * This allows parent components or directives to update the button's disabled state.
     *
     * @param value - Whether the button should be disabled
     *
     * @example
     * ```typescript
     * // In a form component that needs to disable all buttons
     * this.submitButton.setDisabled(this.form.invalid);
     * ```
     */
    setDisabled(value: boolean): void;
    /**
     * Get the current disabled state.
     * Returns the internal disabled state which may have been modified programmatically.
     *
     * @returns True if the button is currently disabled
     *
     * @example
     * ```typescript
     * if (!this.button.isDisabled()) {
     *     this.button.setDisabled(true);
     * }
     * ```
     */
    isDisabled(): boolean;
    /**
     * Programmatically set the button type.
     * This allows directives to override the button's visual style.
     *
     * @param value - The button type to apply
     *
     * @example
     * ```typescript
     * // A directive that changes button style based on validation state
     * if (this.validationFailed) {
     *     this.button.setFdType('negative');
     * }
     * ```
     */
    setFdType(value: ButtonType): void;
    /**
     * Get the current button type.
     * Returns the internal button type which may have been modified programmatically.
     *
     * @returns The current button type
     */
    getFdType(): ButtonType;
    /**
     * Programmatically set the selected state.
     * This allows parent components to update the button's selected state.
     * Used in button groups or toolbars to indicate active selection.
     *
     * @param value - Whether the button should be selected
     *
     * @example
     * ```typescript
     * // In a button group component managing selection
     * this.buttons.forEach(btn => btn.setSelected(false));
     * this.activeButton.setSelected(true);
     * ```
     */
    setSelected(value: boolean): void;
    /**
     * Get the current selected state.
     * Returns the internal selected state which may have been modified programmatically.
     *
     * @returns True if the button is currently selected
     */
    isSelected(): boolean;
    /**
     * Programmatically set the toggled state.
     * This allows parent components to update the button's toggled state.
     * Used for toggle buttons that maintain an on/off state.
     *
     * @param value - Whether the button should be toggled on
     *
     * @example
     * ```typescript
     * // In a toolbar with toggle buttons
     * handleBoldClick(): void {
     *     const isActive = !this.boldButton.isToggled();
     *     this.boldButton.setToggled(isActive);
     * }
     * ```
     */
    setToggled(value: boolean): void;
    /**
     * Get the current toggled state.
     * Returns the internal toggled state which may have been modified programmatically.
     *
     * @returns True if the button is currently toggled
     */
    isToggled(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseButton, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseButton, never, never, { "toggled": { "alias": "toggled"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "glyphPosition": { "alias": "glyphPosition"; "required": false; "isSignal": true; }; "glyph": { "alias": "glyph"; "required": false; "isSignal": true; }; "glyphFont": { "alias": "glyphFont"; "required": false; "isSignal": true; }; "fdType": { "alias": "fdType"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "fdMenu": { "alias": "fdMenu"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaDisabled": { "alias": "aria-disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaDescription": { "alias": "ariaDescription"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const badgeEnabledButtonTypes: ButtonType[];
/**
 * Directive to display a badge on a button.
 *
 * Badges are small status indicators that can be added to buttons to show
 * notifications, counts, or other supplementary information.
 *
 * Usage:
 * ```html
 * <button fd-button>
 *   Button Text
 *   <fd-button-badge [content]="5" />
 * </button>
 * ```
 *
 * @note Badge content should not exceed 4 characters for optimal display.
 * @note Badges are only supported on emphasized, standard, ghost, and transparent button types.
 */
declare class ButtonBadgeDirective implements HasElementRef {
    /**
     * Content to display inside the badge.
     * Should not exceed 4 characters for optimal display.
     * Supports both string and numeric values.
     */
    readonly content: _angular_core.InputSignal<string | number | undefined>;
    /** @hidden */
    readonly elementRef: ElementRef<HTMLElement>;
    /** @hidden */
    protected readonly buttonComponent: BaseButton;
    /** @hidden */
    constructor();
    /**
     * Validates badge configuration in development mode.
     * Checks content length and button type compatibility.
     * @hidden
     */
    private _validateBadge;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonBadgeDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonBadgeDirective, "fd-button-badge", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Button directive, used to enhance standard HTML buttons.
 *
 * ``` selector: button[fd-button], a[fd-button] ```
 *
 * ```html
 * <button fd-button label="Button Text"></button>
 * <a fd-button label="Button Text"></a>
 * ```
 */
declare class ButtonComponent extends BaseButton implements HasElementRef {
    /** Button ID - default value is provided if not set  */
    readonly id: _angular_core.InputSignal<string>;
    /** @hidden */
    readonly elementRef: ElementRef<any>;
    /** @hidden */
    protected readonly contentDensityObserver: ContentDensityObserver;
    /**
     * Calculate aria-label attribute
     * @hidden
     */
    protected readonly buttonArialabel: _angular_core.Signal<string | null | undefined>;
    /**
     * Calculate aria-description attribute
     * @hidden
     */
    protected readonly buttonAriaDescription: _angular_core.Signal<string | null | undefined>;
    /**
     * Computed CSS classes for the button.
     * Built as a string to avoid array allocation overhead.
     * @hidden
     */
    protected readonly cssClass: _angular_core.Signal<string>;
    /**
     * Memoized glyph label for aria-label fallback.
     * Transforms glyph name (e.g., "slim-arrow-down") to readable text (e.g., "slim arrow down").
     * @hidden
     */
    private readonly _glyphLabel;
    /**
     * Native aria-label attribute read from the DOM element.
     * Captured once after render for use in aria-label computation.
     * @hidden
     */
    private readonly _nativeAriaLabel;
    /** @hidden */
    constructor();
    /** Forces the focus outline around the button, which is not default behavior in Safari. */
    protected clicked(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "button[fd-button], a[fd-button], span[fd-button]", ["fd-button"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*", "fd-button-badge"], true, never>;
}

/**
 * @deprecated
 * Use `ButtonComponent` import instead
 */
declare class ButtonModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ButtonModule, never, [typeof ButtonComponent], [typeof ButtonComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ButtonModule>;
}

declare const FD_BUTTON_COMPONENT: InjectionToken<BaseButton>;

export { BaseButton, ButtonBadgeDirective, ButtonComponent, ButtonModule, FD_BUTTON_COMPONENT, badgeEnabledButtonTypes, defaultButtonType };
export type { ButtonModel, ButtonType, GlyphPosition };
