import * as _angular_core from '@angular/core';
import { EnvironmentProviders, OnDestroy, ElementRef, TemplateRef, OnInit } from '@angular/core';
import { ControlValueAccessor } from '@angular/forms';
import { AnimationOptions } from 'ngx-lottie';
import { Highlightable } from '@angular/cdk/a11y';
import * as _camp2gether_c2g_ui from '@camp2gether/c2g-ui';

declare class C2gUi {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<C2gUi, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<C2gUi, "c2g-c2g-ui", never, {}, {}, never, never, true, never>;
}

interface C2gIconsOptions {
    /**
     * Which Material Icons font variants to register.
     * Defaults to all four variants.
     */
    variants?: Array<'filled' | 'outlined' | 'round' | 'sharp'>;
}
/**
 * Registers Material Icons font variants with MatIconRegistry.
 *
 * Add to your app config:
 * ```ts
 * providers: [provideC2gIcons()]
 * ```
 *
 * Then use in templates:
 * ```html
 * <mat-icon>hiking</mat-icon>
 * <mat-icon fontSet="material-icons-outlined">map</mat-icon>
 * <mat-icon fontSet="material-icons-round">star</mat-icon>
 * ```
 *
 * The consuming app must load the font CSS — either via Google Fonts or self-hosted:
 * ```html
 * <link href="https://fonts.googleapis.com/icon?family=Material+Icons|Material+Icons+Outlined|Material+Icons+Round|Material+Icons+Sharp" rel="stylesheet">
 * ```
 */
declare function provideC2gIcons(options?: C2gIconsOptions): EnvironmentProviders;

type C2gAvatarSize = 'sm' | 'md' | 'lg';
type C2gAvatarStatusTone = 'none' | 'neutral' | 'success' | 'danger' | 'muted' | 'custom';
interface C2gAvatarBadge {
    icon?: string;
    text?: string;
    tone?: C2gAvatarStatusTone;
    backgroundColor?: string;
    color?: string;
    ariaLabel?: string;
}

declare class AvatarComponent {
    readonly name: _angular_core.InputSignal<string>;
    readonly initials: _angular_core.InputSignal<string>;
    readonly imageUrl: _angular_core.InputSignal<string | null>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly size: _angular_core.InputSignal<C2gAvatarSize>;
    readonly backgroundColor: _angular_core.InputSignal<string>;
    readonly textColor: _angular_core.InputSignal<string>;
    readonly ringTone: _angular_core.InputSignal<C2gAvatarStatusTone>;
    readonly ringColor: _angular_core.InputSignal<string>;
    readonly clickable: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly badge: _angular_core.InputSignal<C2gAvatarBadge | null>;
    readonly avatarClick: _angular_core.OutputEmitterRef<void>;
    readonly resolvedInitials: _angular_core.Signal<string>;
    readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
    readonly hasImage: _angular_core.Signal<boolean>;
    readonly ringStyle: _angular_core.Signal<string | null>;
    readonly badgeBackground: _angular_core.Signal<string | null>;
    readonly badgeColor: _angular_core.Signal<string | null>;
    onAvatarClick(): void;
    onAvatarKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "c2g-avatar", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "initials": { "alias": "initials"; "required": false; "isSignal": true; }; "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "textColor": { "alias": "textColor"; "required": false; "isSignal": true; }; "ringTone": { "alias": "ringTone"; "required": false; "isSignal": true; }; "ringColor": { "alias": "ringColor"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; }, { "avatarClick": "avatarClick"; }, never, never, true, never>;
}

type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'destructive' | 'icon' | 'outlined' | 'text' | 'elevated' | 'tonal' | 'fab' | 'fab-mini' | 'chip';
type ButtonSize = 'sm' | 'md' | 'lg';
type IconPosition = 'start' | 'end';
declare class ButtonComponent {
    readonly variant: _angular_core.InputSignal<ButtonVariant>;
    readonly size: _angular_core.InputSignal<ButtonSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly icon: _angular_core.InputSignal<string>;
    readonly iconPosition: _angular_core.InputSignal<IconPosition>;
    readonly iconOnly: _angular_core.InputSignal<boolean>;
    readonly bordered: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly loadingAriaLabel: _angular_core.InputSignal<string>;
    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
    readonly badge: _angular_core.InputSignal<string | number | null>;
    readonly active: _angular_core.InputSignal<boolean>;
    readonly iconSize: _angular_core.InputSignal<string>;
    readonly iconColor: _angular_core.InputSignal<string>;
    readonly clicked: _angular_core.OutputEmitterRef<MouseEvent>;
    readonly isInteractionDisabled: _angular_core.Signal<boolean>;
    readonly showLeadingSpinner: _angular_core.Signal<boolean>;
    readonly showTrailingSpinner: _angular_core.Signal<boolean>;
    readonly hasIcon: _angular_core.Signal<boolean>;
    readonly showLeadingIcon: _angular_core.Signal<boolean>;
    readonly showTrailingIcon: _angular_core.Signal<boolean>;
    readonly computedAriaLabel: _angular_core.Signal<string | null>;
    readonly buttonClasses: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "c2g-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconPosition": { "alias": "iconPosition"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loadingAriaLabel": { "alias": "loadingAriaLabel"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
}

type BadgeTone = 'neutral' | 'accent' | 'info' | 'success' | 'warning' | 'danger';
type BadgeVariant = 'solid' | 'subtle' | 'outline';
type BadgeSize = 'sm' | 'md';
declare class BadgeComponent {
    readonly value: _angular_core.InputSignal<string | number>;
    readonly tone: _angular_core.InputSignal<BadgeTone>;
    readonly variant: _angular_core.InputSignal<BadgeVariant>;
    readonly size: _angular_core.InputSignal<BadgeSize>;
    readonly max: _angular_core.InputSignal<number>;
    readonly dot: _angular_core.InputSignal<boolean>;
    readonly dotOnly: _angular_core.InputSignal<boolean>;
    readonly dotRing: _angular_core.InputSignal<boolean>;
    readonly dotPulse: _angular_core.InputSignal<boolean>;
    readonly dotColor: _angular_core.InputSignal<string>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
    readonly content: _angular_core.Signal<string>;
    readonly classes: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BadgeComponent, "c2g-badge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "dotOnly": { "alias": "dotOnly"; "required": false; "isSignal": true; }; "dotRing": { "alias": "dotRing"; "required": false; "isSignal": true; }; "dotPulse": { "alias": "dotPulse"; "required": false; "isSignal": true; }; "dotColor": { "alias": "dotColor"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type ChipTone = 'neutral' | 'accent' | 'info' | 'success' | 'warning' | 'danger';
declare class ChipComponent {
    readonly label: _angular_core.InputSignal<string>;
    readonly tone: _angular_core.InputSignal<ChipTone>;
    readonly selected: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly removable: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly removeAriaLabel: _angular_core.InputSignal<string>;
    readonly icon: _angular_core.InputSignal<string>;
    readonly iconAriaLabel: _angular_core.InputSignal<string>;
    readonly iconFontSet: _angular_core.InputSignal<string>;
    readonly iconFontIcon: _angular_core.InputSignal<string>;
    readonly selectedChange: _angular_core.OutputEmitterRef<boolean>;
    readonly removed: _angular_core.OutputEmitterRef<void>;
    readonly isSelected: _angular_core.WritableSignal<boolean>;
    readonly chipClasses: _angular_core.Signal<string>;
    constructor();
    toggleSelected(): void;
    remove(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChipComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChipComponent, "c2g-chip", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "removeAriaLabel": { "alias": "removeAriaLabel"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconAriaLabel": { "alias": "iconAriaLabel"; "required": false; "isSignal": true; }; "iconFontSet": { "alias": "iconFontSet"; "required": false; "isSignal": true; }; "iconFontIcon": { "alias": "iconFontIcon"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; "removed": "removed"; }, never, never, true, never>;
}

declare class CheckboxComponent implements ControlValueAccessor {
    readonly id: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<string>;
    readonly hint: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
    readonly checked: _angular_core.WritableSignal<boolean>;
    readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
    private readonly generatedId;
    readonly checkboxId: _angular_core.Signal<string>;
    readonly hintId: _angular_core.Signal<string>;
    readonly describedBy: _angular_core.Signal<string | null>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private onChange;
    private onTouched;
    writeValue(value: boolean | null): void;
    registerOnChange(fn: (value: boolean) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "c2g-checkbox", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
}

type C2gLoaderSize = 'sm' | 'md' | 'lg';
type C2gLoaderTone = 'primary' | 'neutral' | 'inverse';
declare class LoaderComponent {
    readonly size: _angular_core.InputSignal<C2gLoaderSize>;
    readonly tone: _angular_core.InputSignal<C2gLoaderTone>;
    readonly label: _angular_core.InputSignal<string>;
    readonly showLabel: _angular_core.InputSignal<boolean>;
    readonly inline: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoaderComponent, "c2g-loader", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const C2G_LOTTIE_PRESET_OPTIONS: readonly ["beach", "camping", "car", "cat-love", "checklist", "coffee-time", "car-driving-landscape", "error-404", "fishing", "mountain-search", "planning", "share", "summer-camp", "thinking", "walking-orange", "walking-avocado", "weather-partly-cloudy"];
type C2gLottieLoaderPreset = (typeof C2G_LOTTIE_PRESET_OPTIONS)[number];
type C2gLottieLoaderPresetMode = 'embedded' | 'path';
declare const C2G_LOTTIE_PRESET_PATHS: Record<C2gLottieLoaderPreset, string>;
declare function loadC2gLottiePresetData(preset: C2gLottieLoaderPreset): Promise<unknown>;

declare class LottieLoaderComponent {
    readonly preset: _angular_core.InputSignal<"beach" | "camping" | "car" | "cat-love" | "checklist" | "coffee-time" | "car-driving-landscape" | "error-404" | "fishing" | "mountain-search" | "planning" | "share" | "summer-camp" | "thinking" | "walking-orange" | "walking-avocado" | "weather-partly-cloudy">;
    readonly presetMode: _angular_core.InputSignal<C2gLottieLoaderPresetMode>;
    readonly animationPath: _angular_core.InputSignal<string>;
    readonly animationData: _angular_core.InputSignal<unknown>;
    readonly loop: _angular_core.InputSignal<boolean>;
    readonly autoplay: _angular_core.InputSignal<boolean>;
    readonly width: _angular_core.InputSignal<string>;
    readonly height: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<string>;
    readonly showLabel: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.Signal<string>;
    private readonly lazyPresetData;
    readonly hasRenderableAnimation: _angular_core.Signal<boolean>;
    constructor();
    private cloneAnimationData;
    readonly options: _angular_core.Signal<AnimationOptions>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LottieLoaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LottieLoaderComponent, "c2g-lottie-loader", never, { "preset": { "alias": "preset"; "required": false; "isSignal": true; }; "presetMode": { "alias": "presetMode"; "required": false; "isSignal": true; }; "animationPath": { "alias": "animationPath"; "required": false; "isSignal": true; }; "animationData": { "alias": "animationData"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "autoplay": { "alias": "autoplay"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type C2gSkeletonVariant = 'text' | 'block' | 'avatar';
declare class SkeletonComponent {
    readonly variant: _angular_core.InputSignal<C2gSkeletonVariant>;
    readonly width: _angular_core.InputSignal<string>;
    readonly height: _angular_core.InputSignal<string>;
    readonly radius: _angular_core.InputSignal<string>;
    readonly animated: _angular_core.InputSignal<boolean>;
    readonly resolvedWidth: _angular_core.Signal<string>;
    readonly resolvedHeight: _angular_core.Signal<string>;
    readonly resolvedRadius: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonComponent, "c2g-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type C2gAlertTone = 'info' | 'success' | 'warning' | 'danger';
type C2gAlertVariant = 'soft' | 'solid' | 'outline';
declare class AlertComponent {
    readonly tone: _angular_core.InputSignal<C2gAlertTone>;
    readonly variant: _angular_core.InputSignal<C2gAlertVariant>;
    readonly title: _angular_core.InputSignal<string>;
    readonly message: _angular_core.InputSignal<string>;
    readonly open: _angular_core.InputSignal<boolean | undefined>;
    readonly dismissible: _angular_core.InputSignal<boolean>;
    readonly closeLabel: _angular_core.InputSignal<string>;
    readonly dismissed: _angular_core.OutputEmitterRef<void>;
    readonly internalVisible: _angular_core.WritableSignal<boolean>;
    readonly visible: _angular_core.Signal<boolean>;
    readonly liveRole: _angular_core.Signal<"alert" | "status">;
    readonly ariaLive: _angular_core.Signal<"assertive" | "polite">;
    readonly iconSymbol: _angular_core.Signal<"v" | "!" | "x" | "i">;
    dismiss(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertComponent, "c2g-alert", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, never, true, never>;
}

type C2gProgressTone = 'primary' | 'success' | 'warning' | 'danger';
type C2gProgressSize = 'sm' | 'md' | 'lg';
declare class ProgressComponent {
    readonly value: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly size: _angular_core.InputSignal<C2gProgressSize>;
    readonly tone: _angular_core.InputSignal<C2gProgressTone>;
    readonly label: _angular_core.InputSignal<string>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly showLabel: _angular_core.InputSignal<boolean>;
    readonly striped: _angular_core.InputSignal<boolean>;
    readonly animated: _angular_core.InputSignal<boolean>;
    readonly indeterminate: _angular_core.InputSignal<boolean>;
    readonly safeMax: _angular_core.Signal<number>;
    readonly clampedValue: _angular_core.Signal<number>;
    readonly percent: _angular_core.Signal<number>;
    readonly percentLabel: _angular_core.Signal<string>;
    readonly resolvedAriaLabel: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressComponent, "c2g-progress", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class InputComponent implements ControlValueAccessor {
    readonly label: _angular_core.InputSignal<string>;
    readonly hint: _angular_core.InputSignal<string>;
    readonly error: _angular_core.InputSignal<string>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly prefix: _angular_core.InputSignal<string>;
    readonly suffix: _angular_core.InputSignal<string>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly compact: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly maxLength: _angular_core.InputSignal<number | null>;
    readonly id: _angular_core.InputSignal<string>;
    readonly type: _angular_core.InputSignal<"text" | "email" | "password" | "search" | "tel" | "url">;
    readonly size: _angular_core.InputSignal<"sm" | "md">;
    readonly valueChanged: _angular_core.OutputEmitterRef<string>;
    readonly value: _angular_core.WritableSignal<string>;
    readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
    private readonly generatedId;
    readonly inputId: _angular_core.Signal<string>;
    readonly hintId: _angular_core.Signal<string>;
    readonly errorId: _angular_core.Signal<string>;
    readonly counterId: _angular_core.Signal<string>;
    readonly describedBy: _angular_core.Signal<string | null>;
    readonly valueLength: _angular_core.Signal<number>;
    readonly showCounter: _angular_core.Signal<boolean>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private onChange;
    private onTouched;
    writeValue(value: string | null): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "c2g-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
}

interface RadioOption<T extends string = string> {
    value: T;
    label: string;
    hint?: string;
    disabled?: boolean;
}

declare class RadioGroupComponent<T extends string = string> implements ControlValueAccessor {
    readonly label: _angular_core.InputSignal<string>;
    readonly hint: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
    readonly options: _angular_core.InputSignal<RadioOption<T>[]>;
    readonly name: _angular_core.InputSignal<string>;
    readonly valueChange: _angular_core.OutputEmitterRef<T>;
    readonly value: _angular_core.WritableSignal<T | null>;
    readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
    private readonly generatedName;
    readonly groupName: _angular_core.Signal<string>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private onChange;
    private onTouched;
    writeValue(value: T | null): void;
    registerOnChange(fn: (value: T) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    isOptionDisabled(option: RadioOption<T>): boolean;
    selectOption(next: T): void;
    onBlur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroupComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent<any>, "c2g-radio-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

interface SelectOption<T extends string = string> {
    value: T;
    label: string;
    disabled?: boolean;
}
type SelectValue = string | null;

declare class SelectComponent<T extends string = string> implements ControlValueAccessor, OnDestroy {
    readonly label: _angular_core.InputSignal<string>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly hint: _angular_core.InputSignal<string>;
    readonly error: _angular_core.InputSignal<string>;
    readonly options: _angular_core.InputSignal<SelectOption<T>[]>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly compact: _angular_core.InputSignal<boolean>;
    readonly id: _angular_core.InputSignal<string>;
    readonly multiple: _angular_core.InputSignal<boolean>;
    readonly valueChanged: _angular_core.OutputEmitterRef<T | null>;
    readonly value: _angular_core.WritableSignal<T | null>;
    readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
    readonly open: _angular_core.WritableSignal<boolean>;
    readonly activeDescendant: _angular_core.WritableSignal<string | null>;
    private readonly generatedId;
    readonly selectId: _angular_core.Signal<string>;
    readonly panelId: _angular_core.Signal<string>;
    readonly hintId: _angular_core.Signal<string>;
    readonly errorId: _angular_core.Signal<string>;
    readonly describedBy: _angular_core.Signal<string | null>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly displayValue: _angular_core.Signal<string>;
    triggerRef: ElementRef;
    panelTpl: TemplateRef<void>;
    private overlay;
    private vcr;
    private cdr;
    private overlayRef;
    private panelRef;
    private onChange;
    private onTouched;
    writeValue(value: T | null): void;
    registerOnChange(fn: (value: T | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    toggle(): void;
    openPanel(): void;
    close(): void;
    onOptionSelected(value: T): void;
    onBlur(): void;
    onKeydown(event: KeyboardEvent): void;
    onDocEscape(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent<any>, "c2g-select", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
}

declare class SelectOptionComponent<T = string> implements Highlightable, OnInit {
    readonly value: _angular_core.InputSignal<T>;
    readonly label: _angular_core.InputSignal<string>;
    readonly disabledInput: _angular_core.InputSignal<boolean>;
    /** Satisfies `Highlightable.disabled: boolean | undefined` */
    get disabled(): boolean;
    readonly optionId: string;
    /** Set by the parent panel when this option matches the current value */
    selected: boolean;
    _active: boolean;
    private cdr;
    private _elementRef;
    get element(): HTMLElement;
    ngOnInit(): void;
    setActiveStyles(): void;
    setInactiveStyles(): void;
    getLabel(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectOptionComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectOptionComponent<any>, "c2g-select-option", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SwitchComponent implements ControlValueAccessor {
    readonly id: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<string>;
    readonly hint: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
    readonly checked: _angular_core.WritableSignal<boolean>;
    readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
    private readonly generatedId;
    readonly switchId: _angular_core.Signal<string>;
    readonly hintId: _angular_core.Signal<string>;
    readonly describedBy: _angular_core.Signal<string | null>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private onChange;
    private onTouched;
    writeValue(value: boolean | null): void;
    registerOnChange(fn: (value: boolean) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    toggle(): void;
    markTouched(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "c2g-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
}

type TagTone = 'neutral' | 'accent' | 'info' | 'success' | 'warning' | 'danger';
type TagVariant = 'subtle' | 'solid' | 'outline';
type TagSize = 'sm' | 'md';
declare class TagComponent {
    readonly label: _angular_core.InputSignal<string>;
    readonly tone: _angular_core.InputSignal<TagTone>;
    readonly variant: _angular_core.InputSignal<TagVariant>;
    readonly size: _angular_core.InputSignal<TagSize>;
    readonly dashed: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly icon: _angular_core.InputSignal<string>;
    readonly iconAriaLabel: _angular_core.InputSignal<string>;
    readonly iconFontSet: _angular_core.InputSignal<string>;
    readonly iconFontIcon: _angular_core.InputSignal<string>;
    readonly classes: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "c2g-tag", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dashed": { "alias": "dashed"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconAriaLabel": { "alias": "iconAriaLabel"; "required": false; "isSignal": true; }; "iconFontSet": { "alias": "iconFontSet"; "required": false; "isSignal": true; }; "iconFontIcon": { "alias": "iconFontIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TextareaComponent implements ControlValueAccessor {
    readonly label: _angular_core.InputSignal<string>;
    readonly hint: _angular_core.InputSignal<string>;
    readonly error: _angular_core.InputSignal<string>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly prefix: _angular_core.InputSignal<string>;
    readonly suffix: _angular_core.InputSignal<string>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly maxLength: _angular_core.InputSignal<number | null>;
    readonly rows: _angular_core.InputSignal<number>;
    readonly id: _angular_core.InputSignal<string>;
    readonly valueChanged: _angular_core.OutputEmitterRef<string>;
    readonly value: _angular_core.WritableSignal<string>;
    readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
    private readonly generatedId;
    readonly textareaId: _angular_core.Signal<string>;
    readonly hintId: _angular_core.Signal<string>;
    readonly errorId: _angular_core.Signal<string>;
    readonly counterId: _angular_core.Signal<string>;
    readonly describedBy: _angular_core.Signal<string | null>;
    readonly valueLength: _angular_core.Signal<number>;
    readonly showCounter: _angular_core.Signal<boolean>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private onChange;
    private onTouched;
    writeValue(value: string | null): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(event: Event): void;
    onBlur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "c2g-textarea", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
}

type ModalSize = 'sm' | 'md' | 'lg' | 'xl';

declare class ModalComponent {
    private readonly document;
    readonly open: _angular_core.InputSignal<boolean>;
    readonly title: _angular_core.InputSignal<string>;
    readonly size: _angular_core.InputSignal<ModalSize>;
    readonly closable: _angular_core.InputSignal<boolean>;
    readonly lockBodyScroll: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string>;
    readonly closed: _angular_core.OutputEmitterRef<void>;
    readonly effectiveAriaLabel: _angular_core.Signal<string>;
    readonly sizeClass: _angular_core.Signal<string>;
    constructor();
    close(): void;
    onBackdropClick(event: MouseEvent): void;
    onKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "c2g-modal", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "lockBodyScroll": { "alias": "lockBodyScroll"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*", "[c2g-modal-footer]"], true, never>;
}

type C2gToastTone = 'success' | 'error' | 'warning' | 'info';
interface C2gToast {
    id: string;
    message: string;
    tone: C2gToastTone;
    duration?: number;
    action?: {
        label: string;
        callback: () => void;
    };
}

declare class ToastService {
    readonly toasts: _angular_core.WritableSignal<C2gToast[]>;
    private show;
    success(message: string, duration?: number): void;
    error(message: string, duration?: number): void;
    warning(message: string, duration?: number): void;
    info(message: string, duration?: number): void;
    withAction(message: string, tone: C2gToastTone, action: C2gToast['action']): void;
    dismiss(id: string): void;
    dismissAll(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ToastService>;
}

declare class ToastContainerComponent {
    readonly toastService: ToastService;
    readonly toasts: _angular_core.WritableSignal<_camp2gether_c2g_ui.C2gToast[]>;
    dismiss(id: string): void;
    toneIcon(tone: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastContainerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastContainerComponent, "c2g-toast-container", never, {}, {}, never, never, true, never>;
}

type C2gConfirmTone = 'danger' | 'warning' | 'info';
interface C2gConfirmDialogData {
    title: string;
    message: string;
    tone?: C2gConfirmTone;
    confirmLabel?: string;
    cancelLabel?: string;
    icon?: string;
}

declare class ConfirmDialogComponent {
    readonly open: _angular_core.InputSignal<boolean>;
    readonly data: _angular_core.InputSignal<C2gConfirmDialogData>;
    readonly confirmed: _angular_core.OutputEmitterRef<void>;
    readonly cancelled: _angular_core.OutputEmitterRef<void>;
    readonly confirmLabel: _angular_core.Signal<string>;
    readonly cancelLabel: _angular_core.Signal<string>;
    readonly tone: _angular_core.Signal<_camp2gether_c2g_ui.C2gConfirmTone>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDialogComponent, "c2g-confirm-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": true; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
}

interface C2gDateRange {
    from: Date | null;
    to: Date | null;
}

interface CalendarDay {
    date: Date;
    currentMonth: boolean;
    today: boolean;
    inRange: boolean;
    isStart: boolean;
    isEnd: boolean;
    disabled: boolean;
}
declare class DateRangePickerComponent implements OnDestroy {
    readonly value: _angular_core.ModelSignal<C2gDateRange>;
    readonly minDate: _angular_core.InputSignal<Date | null>;
    readonly maxDate: _angular_core.InputSignal<Date | null>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly rangeChanged: _angular_core.OutputEmitterRef<C2gDateRange>;
    readonly open: _angular_core.WritableSignal<boolean>;
    readonly viewDate: _angular_core.WritableSignal<Date>;
    readonly hoverDate: _angular_core.WritableSignal<Date | null>;
    readonly weekdays: string[];
    readonly months: string[];
    triggerRef: ElementRef;
    calendarTpl: TemplateRef<void>;
    private overlay;
    private vcr;
    private overlayRef;
    readonly monthLabel: _angular_core.Signal<string>;
    readonly days: _angular_core.Signal<CalendarDay[]>;
    readonly displayValue: _angular_core.Signal<string>;
    toggleOpen(): void;
    openCalendar(): void;
    closeCalendar(): void;
    prevMonth(): void;
    nextMonth(): void;
    onDayClick(day: CalendarDay): void;
    onDayHover(day: CalendarDay): void;
    clearRange(): void;
    onEscape(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangePickerComponent, "c2g-date-range-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "rangeChanged": "rangeChanged"; }, never, never, true, never>;
}

type StepperVariant = 'dot' | 'progress';
declare class StepperComponent {
    /** Total number of steps in the wizard. */
    readonly totalSteps: _angular_core.InputSignal<number>;
    /** Zero-based index of the current active step. */
    readonly currentStep: _angular_core.InputSignal<number>;
    /**
     * Visual variant:
     * - `dot` — animated dot row in the header (onboarding style)
     * - `progress` — progress bar only, no dot row
     */
    readonly variant: _angular_core.InputSignal<StepperVariant>;
    /** Whether to render the footer navigation (back / next / finish). */
    readonly hideFooter: _angular_core.InputSignal<boolean>;
    /** Whether to show the step-count label (e.g. "2 of 5"). */
    readonly showStepLabel: _angular_core.InputSignal<boolean>;
    /**
     * Whether to also render a `c2g-progress` bar below the header.
     * When `variant` is `'progress'`, a bar is always rendered.
     * For `'dot'` variant, set this to `true` to render both a dot row and a bar.
     */
    readonly showProgressBar: _angular_core.InputSignal<boolean>;
    /** Whether to show the close/skip icon button in the header. */
    readonly showClose: _angular_core.InputSignal<boolean>;
    /** Label for the "Back" button. */
    readonly backLabel: _angular_core.InputSignal<string>;
    /** Label for the "Next" button. */
    readonly nextLabel: _angular_core.InputSignal<string>;
    /** Label for the "Finish" button on the last step. */
    readonly finishLabel: _angular_core.InputSignal<string>;
    /**
     * Pre-formatted step label string (e.g. "Schritt 2 von 5").
     * When empty the component renders "Step {n} of {total}" using default logic.
     */
    readonly stepLabelText: _angular_core.InputSignal<string>;
    /** Whether the user can advance to the next step. */
    readonly canAdvance: _angular_core.InputSignal<boolean>;
    /** Accessible label for the host group element. */
    readonly ariaLabel: _angular_core.InputSignal<string>;
    /** Accessible label for the close/skip button. */
    readonly closeAriaLabel: _angular_core.InputSignal<string>;
    /** Emitted when the user clicks the "Next" button. */
    readonly next: _angular_core.OutputEmitterRef<void>;
    /** Emitted when the user clicks the "Back" button. */
    readonly back: _angular_core.OutputEmitterRef<void>;
    /** Emitted when the user clicks the "Finish" button on the last step. */
    readonly finish: _angular_core.OutputEmitterRef<void>;
    /** Emitted when the user clicks the close/skip button. */
    readonly closed: _angular_core.OutputEmitterRef<void>;
    /** Array of zero-based step indices for `@for` rendering. */
    readonly stepIndices: _angular_core.Signal<number[]>;
    readonly isFirst: _angular_core.Signal<boolean>;
    readonly isLast: _angular_core.Signal<boolean>;
    readonly stepLabel: _angular_core.Signal<string>;
    readonly progressAriaLabel: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepperComponent, "c2g-stepper", never, { "totalSteps": { "alias": "totalSteps"; "required": true; "isSignal": true; }; "currentStep": { "alias": "currentStep"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "hideFooter": { "alias": "hideFooter"; "required": false; "isSignal": true; }; "showStepLabel": { "alias": "showStepLabel"; "required": false; "isSignal": true; }; "showProgressBar": { "alias": "showProgressBar"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "backLabel": { "alias": "backLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "finishLabel": { "alias": "finishLabel"; "required": false; "isSignal": true; }; "stepLabelText": { "alias": "stepLabelText"; "required": false; "isSignal": true; }; "canAdvance": { "alias": "canAdvance"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "closeAriaLabel": { "alias": "closeAriaLabel"; "required": false; "isSignal": true; }; }, { "next": "next"; "back": "back"; "finish": "finish"; "closed": "closed"; }, never, ["*"], true, never>;
}

interface PackingGap {
    category: string;
    severity: 'critical' | 'warning' | 'info';
    message: string;
    suggested_items?: string[];
}
declare class PackingGapBannerComponent {
    readonly gaps: _angular_core.InputSignal<PackingGap[]>;
    readonly expanded: _angular_core.WritableSignal<boolean>;
    readonly criticalCount: _angular_core.Signal<number>;
    readonly hasCritical: _angular_core.Signal<boolean>;
    readonly hasGaps: _angular_core.Signal<boolean>;
    toggle(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackingGapBannerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackingGapBannerComponent, "c2g-packing-gap-banner", never, { "gaps": { "alias": "gaps"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface C2gDropdownMenuItem {
    id: string;
    label: string;
    icon?: string;
    danger?: boolean;
    disabled?: boolean;
    dividerBefore?: boolean;
}
declare class DropdownMenuComponent implements OnDestroy {
    readonly items: _angular_core.InputSignal<C2gDropdownMenuItem[]>;
    readonly triggerLabel: _angular_core.InputSignal<string>;
    readonly triggerIcon: _angular_core.InputSignal<string>;
    readonly alignEnd: _angular_core.InputSignal<boolean>;
    readonly itemSelected: _angular_core.OutputEmitterRef<C2gDropdownMenuItem>;
    readonly open: _angular_core.WritableSignal<boolean>;
    triggerRef: ElementRef;
    menuTpl: TemplateRef<void>;
    private overlay;
    private vcr;
    private overlayRef;
    toggle(): void;
    openMenu(): void;
    close(): void;
    selectItem(item: C2gDropdownMenuItem): void;
    onEscape(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownMenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownMenuComponent, "c2g-dropdown-menu", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "triggerLabel": { "alias": "triggerLabel"; "required": false; "isSignal": true; }; "triggerIcon": { "alias": "triggerIcon"; "required": false; "isSignal": true; }; "alignEnd": { "alias": "alignEnd"; "required": false; "isSignal": true; }; }, { "itemSelected": "itemSelected"; }, never, never, true, never>;
}

type PopupAlign = 'start' | 'end';
type PopupPosition = 'bottom' | 'top';
declare class PopupComponent implements OnDestroy {
    readonly align: _angular_core.InputSignal<PopupAlign>;
    readonly position: _angular_core.InputSignal<PopupPosition>;
    readonly minWidth: _angular_core.InputSignal<string>;
    readonly maxWidth: _angular_core.InputSignal<string>;
    readonly opened: _angular_core.OutputEmitterRef<void>;
    readonly closed: _angular_core.OutputEmitterRef<void>;
    readonly open: _angular_core.WritableSignal<boolean>;
    private triggerRef;
    private panelTpl;
    private readonly overlay;
    private readonly vcr;
    private overlayRef;
    toggle(): void;
    openPanel(): void;
    closePanel(): void;
    onEscape(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopupComponent, "c2g-popup", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, ["[trigger]", "[panel]"], true, never>;
}

interface C2gWeatherDay {
    date: string;
    icon: string;
    description: string;
    temperature: {
        min: number;
        max: number;
    };
}
declare function resolveIcon(icon: string): string;
declare class WeatherWidgetComponent {
    readonly currentDay: _angular_core.InputSignal<C2gWeatherDay | null>;
    readonly forecastSlots: _angular_core.InputSignal<C2gWeatherDay[]>;
    readonly destination: _angular_core.InputSignal<string>;
    readonly icon: _angular_core.Signal<string>;
    resolveIcon: typeof resolveIcon;
    slotLabel(index: number, total: number): string;
    shortDate(date: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WeatherWidgetComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WeatherWidgetComponent, "c2g-weather-widget", never, { "currentDay": { "alias": "currentDay"; "required": false; "isSignal": true; }; "forecastSlots": { "alias": "forecastSlots"; "required": false; "isSignal": true; }; "destination": { "alias": "destination"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface C2gWeatherSnippet {
    icon: string;
    temp: number;
}
declare class C2gDatePresetCardComponent {
    readonly icon: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<string>;
    readonly dateRange: _angular_core.InputSignal<string>;
    readonly weather: _angular_core.InputSignal<C2gWeatherSnippet | null | undefined>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly cardClicked: _angular_core.OutputEmitterRef<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<C2gDatePresetCardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<C2gDatePresetCardComponent, "c2g-date-preset-card", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "dateRange": { "alias": "dateRange"; "required": false; "isSignal": true; }; "weather": { "alias": "weather"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "cardClicked": "cardClicked"; }, never, never, true, never>;
}

export { AlertComponent, AvatarComponent, BadgeComponent, ButtonComponent, C2G_LOTTIE_PRESET_OPTIONS, C2G_LOTTIE_PRESET_PATHS, C2gDatePresetCardComponent, C2gUi, CheckboxComponent, ChipComponent, ConfirmDialogComponent, DateRangePickerComponent, DropdownMenuComponent, InputComponent, LoaderComponent, LottieLoaderComponent, ModalComponent, PackingGapBannerComponent, PopupComponent, ProgressComponent, RadioGroupComponent, SelectComponent, SelectOptionComponent, SkeletonComponent, StepperComponent, SwitchComponent, TagComponent, TextareaComponent, ToastContainerComponent, ToastService, WeatherWidgetComponent, loadC2gLottiePresetData, provideC2gIcons };
export type { BadgeSize, BadgeTone, BadgeVariant, ButtonSize, ButtonVariant, C2gAlertTone, C2gAlertVariant, C2gAvatarBadge, C2gAvatarSize, C2gAvatarStatusTone, C2gConfirmDialogData, C2gConfirmTone, C2gDateRange, C2gDropdownMenuItem, C2gIconsOptions, C2gLoaderSize, C2gLoaderTone, C2gLottieLoaderPreset, C2gLottieLoaderPresetMode, C2gProgressSize, C2gProgressTone, C2gSkeletonVariant, C2gToast, C2gToastTone, C2gWeatherDay, C2gWeatherSnippet, ChipTone, IconPosition, ModalSize, PackingGap, PopupAlign, PopupPosition, RadioOption, SelectOption, SelectValue, StepperVariant, TagSize, TagTone, TagVariant };