/**
 * AUTO-GENERATED FILE - DO NOT EDIT.
 * Generated from custom-elements manifest.
 */

import type React from 'react';
import type { ExpressionBuilder as ExpressionBuilderWC } from './main/expression-builder';
import type { ExpressionGroup as ExpressionGroupWC } from './main/expression-group/expression-group';
import type { ExpressionRule as ExpressionRuleWC } from './main/expression-rule/expression-rule';
import type { RuleField as RuleFieldWC } from './main/rule-field/rule-field';
import type { RuleOperator as RuleOperatorWC } from './main/rule-operator/rule-operator';
import type { RuleValue as RuleValueWC } from './main/rule-value/rule-value';

/** @internal Maps a web component class to its public props only.
 * keyof T skips private/protected members, so this avoids the TS error
 * "property may not be private or protected" on exported anonymous types. */
type PublicOf<T> = { [K in keyof T]?: T[K] };

/** @internal Safe React HTML attributes for web component wrappers.
 * onChange/onInput use method signatures for bivariant parameter checking so both
 * native Event and CustomEvent callbacks are accepted. */
interface HTMLWCProps extends React.AriaAttributes {
  className?: string; style?: React.CSSProperties; id?: string; slot?: string;
  tabIndex?: number; dir?: string; lang?: string; title?: string;
  onClick?: React.MouseEventHandler<HTMLElement>;
  onDoubleClick?: React.MouseEventHandler<HTMLElement>;
  onContextMenu?: React.MouseEventHandler<HTMLElement>;
  onMouseEnter?: React.MouseEventHandler<HTMLElement>;
  onMouseLeave?: React.MouseEventHandler<HTMLElement>;
  onMouseDown?: React.MouseEventHandler<HTMLElement>;
  onMouseUp?: React.MouseEventHandler<HTMLElement>;
  onMouseMove?: React.MouseEventHandler<HTMLElement>;
  onKeyDown?: React.KeyboardEventHandler<HTMLElement>;
  onKeyUp?: React.KeyboardEventHandler<HTMLElement>;
  onFocus?: React.FocusEventHandler<HTMLElement>;
  onBlur?: React.FocusEventHandler<HTMLElement>;
  onScroll?: React.UIEventHandler<HTMLElement>;
  onWheel?: React.WheelEventHandler<HTMLElement>;
  onChange?(e: Event): void;
  onInput?(e: Event): void;
}

export declare const ExpressionBuilder: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ExpressionBuilderWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onAddGroup?: (event: CustomEvent<unknown>) => void;
      onDelGroup?: (event: CustomEvent<unknown>) => void;
      onAddRule?: (event: CustomEvent<unknown>) => void;
      onDelRule?: (event: CustomEvent<unknown>) => void;
      onUpdateGroup?: (event: CustomEvent<unknown>) => void;
      onUpdateRule?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<ExpressionBuilderWC>
>;
export type ExpressionBuilderRef = ExpressionBuilderWC;

export declare const ExpressionGroup: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ExpressionGroupWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onAddRule?: (event: CustomEvent<unknown>) => void;
      onAddGroup?: (event: CustomEvent<unknown>) => void;
      onDelGroup?: (event: CustomEvent<unknown>) => void;
      onUpdateGroup?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<ExpressionGroupWC>
>;
export type ExpressionGroupRef = ExpressionGroupWC;

export declare const ExpressionRule: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ExpressionRuleWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onDelRule?: (event: CustomEvent<unknown>) => void;
      onUpdateRule?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<ExpressionRuleWC>
>;
export type ExpressionRuleRef = ExpressionRuleWC;

export declare const RuleField: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<RuleFieldWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onFieldSelected?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<RuleFieldWC>
>;
export type RuleFieldRef = RuleFieldWC;

export declare const RuleOperator: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<RuleOperatorWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onOperatorSelected?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<RuleOperatorWC>
>;
export type RuleOperatorRef = RuleOperatorWC;

export declare const RuleValue: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<RuleValueWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onValueUpdated?: (event: CustomEvent<unknown>) => void;
      onRemoveVariadicOperand?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<RuleValueWC>
>;
export type RuleValueRef = RuleValueWC;

export {};