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

import type React from 'react';
import type { ConfigurationDatasources as ConfigurationDatasourcesWC } from './components/configurations-panel/configuration-datasources/configuration-datasources';
import type { ConfigurationsPanel as ConfigurationsPanelWC } from './components/configurations-panel/configurations-panel';
import type { ReconciliationRuleRow as ReconciliationRuleRowWC } from './components/configurations-panel/reconciliation-rule-row/reconciliation-rule-row';
import type { DataDictionaries as DataDictionariesWC } from './components/data-dictionaries/data-dictionaries';
import type { List as ListWC } from './components/list/list';
import type { InputParameter as InputParameterWC } from './components/reconciliations-panel/input-parameter/input-parameter';
import type { ReconciliationsPanel as ReconciliationsPanelWC } from './components/reconciliations-panel/reconciliations-panel';
import type { ResultDetails as ResultDetailsWC } from './components/reconciliations-panel/result-details/result-details';
import type { RapidReconciliation as RapidReconciliationWC, ZeroReconciliation as ZeroReconciliationWC } from './main/main';
import type { ReconciliationSandbox as ReconciliationSandboxWC } from './sandbox';
import type { Configuration, DataDictionary, Datasource, ReconConfigurationRule, UploadedEventDetail } from '@genesislcap/pbc-reconciliation-ui';

/** @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 ReconciliationSandbox: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ReconciliationSandboxWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ReconciliationSandboxWC>
>;
export type ReconciliationSandboxRef = ReconciliationSandboxWC;

export declare const RapidReconciliation: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<RapidReconciliationWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<RapidReconciliationWC>
>;
export type RapidReconciliationRef = RapidReconciliationWC;

export declare const ZeroReconciliation: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ZeroReconciliationWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ZeroReconciliationWC>
>;
export type ZeroReconciliationRef = ZeroReconciliationWC;

export declare const ConfigurationsPanel: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ConfigurationsPanelWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ConfigurationsPanelWC>
>;
export type ConfigurationsPanelRef = ConfigurationsPanelWC;

export declare const DataDictionaries: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DataDictionariesWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<DataDictionariesWC>
>;
export type DataDictionariesRef = DataDictionariesWC;

export declare const List: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ListWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onAddRecord?: (event: CustomEvent<unknown>) => void;
      onSelectRecord?: (event: CustomEvent<Configuration | DataDictionary>) => void;
      onDeleteRecord?: (event: CustomEvent<number>) => void;
    }
  > & React.RefAttributes<ListWC>
>;
export type ListRef = ListWC;

export declare const ConfigurationDatasources: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ConfigurationDatasourcesWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onAddDatasource?: (event: CustomEvent<Datasource>) => void;
    }
  > & React.RefAttributes<ConfigurationDatasourcesWC>
>;
export type ConfigurationDatasourcesRef = ConfigurationDatasourcesWC;

export declare const ReconciliationsPanel: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ReconciliationsPanelWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ReconciliationsPanelWC>
>;
export type ReconciliationsPanelRef = ReconciliationsPanelWC;

export declare const ReconciliationRuleRow: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ReconciliationRuleRowWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onAddRule?: (event: CustomEvent<ReconConfigurationRule>) => void;
      onDeleteRule?: (event: CustomEvent<unknown>) => void;
      onUpdateRule?: (event: CustomEvent<ReconConfigurationRule>) => void;
    }
  > & React.RefAttributes<ReconciliationRuleRowWC>
>;
export type ReconciliationRuleRowRef = ReconciliationRuleRowWC;

export declare const InputParameter: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<InputParameterWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onUploaded?: (event: CustomEvent<UploadedEventDetail>) => void;
    }
  > & React.RefAttributes<InputParameterWC>
>;
export type InputParameterRef = InputParameterWC;

export declare const ResultDetails: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ResultDetailsWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ResultDetailsWC>
>;
export type ResultDetailsRef = ResultDetailsWC;

export {};