@episource/signet-angular/src/generated/directives/proxies.ts

Develop your Angular application using Signet's Angular component library.

/* tslint:disable */
/* auto-generated angular directive proxies */
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, NgZone } from '@angular/core';
import { ProxyCmp, proxyOutputs } from './angular-component-lib/utils';

import { Components } from '@episource/signet';




export declare interface CardBody extends Components.CardBody {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['cardTitle']
})
@Component({
  selector: 'card-body',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['cardTitle']
})
export class CardBody {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface CardFooter extends Components.CardFooter {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'card-footer',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class CardFooter {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface CheckmarkItem extends Components.CheckmarkItem {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['isActive', 'isValid']
})
@Component({
  selector: 'checkmark-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['isActive', 'isValid']
})
export class CheckmarkItem {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface DataGrid extends Components.DataGrid {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'data-grid',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class DataGrid {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface DatagridFilterCheckbox extends Components.DatagridFilterCheckbox {
  /**
   * The type of filter.
This is used to identify the filter type in the event emitted.
Example: "datagrid-filter-checkbox"
This is useful for identifying the filter type in the event handler.
This is optional and can be used for custom filter types.
Example: "custom-filter-type" 
   */
  filterChanged: EventEmitter<CustomEvent<{ grid_id: string; field: string; value: any; type: string; }>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'options']
})
@Component({
  selector: 'datagrid-filter-checkbox',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'options']
})
export class DatagridFilterCheckbox {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['filterChanged']);
  }
}


export declare interface DatagridFilterCheckboxEligibleYear extends Components.DatagridFilterCheckboxEligibleYear {
  /**
   * The type of the filter.
This is used to identify the type of filter in the UI. 
   */
  filterChanged: EventEmitter<CustomEvent<{ grid_id: string; field: string; value: any; type: string; }>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'options']
})
@Component({
  selector: 'datagrid-filter-checkbox-eligible-year',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'options']
})
export class DatagridFilterCheckboxEligibleYear {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['filterChanged']);
  }
}


export declare interface DatagridFilterDateRange extends Components.DatagridFilterDateRange {
  /**
   *  
   */
  filterChanged: EventEmitter<CustomEvent<{ grid_id: string; field: string; value: { startDate: string; endDate: string }; type: string; }>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'type']
})
@Component({
  selector: 'datagrid-filter-date-range',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'type']
})
export class DatagridFilterDateRange {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['filterChanged']);
  }
}


export declare interface DatagridFilterDropdown extends Components.DatagridFilterDropdown {
  /**
   *  
   */
  filterChanged: EventEmitter<CustomEvent<{ grid_id: string; field: string; value: string; type: string; }>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'options']
})
@Component({
  selector: 'datagrid-filter-dropdown',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'options']
})
export class DatagridFilterDropdown {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['filterChanged']);
  }
}


export declare interface DatagridFilterDropdownLogic extends Components.DatagridFilterDropdownLogic {
  /**
   *  
   */
  filterChanged: EventEmitter<CustomEvent<{ grid_id: string; field: string; value: number; type: string; condition: string; }>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'options', 'type']
})
@Component({
  selector: 'datagrid-filter-dropdown-logic',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'options', 'type']
})
export class DatagridFilterDropdownLogic {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['filterChanged']);
  }
}


export declare interface DatagridFilterTextInput extends Components.DatagridFilterTextInput {
  /**
   *  
   */
  filterChanged: EventEmitter<CustomEvent<{ grid_id: string; field: string; value: string; type: string; }>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'placeholder']
})
@Component({
  selector: 'datagrid-filter-text-input',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'placeholder']
})
export class DatagridFilterTextInput {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['filterChanged']);
  }
}


export declare interface DatagridSearchTextInput extends Components.DatagridSearchTextInput {
  /**
   *  
   */
  filterChanged: EventEmitter<CustomEvent<{ grid_id: string; field: string; value: string; type: string; }>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'placeholder']
})
@Component({
  selector: 'datagrid-search-text-input',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['field', 'grid_id', 'initialValue', 'label', 'placeholder']
})
export class DatagridSearchTextInput {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['filterChanged']);
  }
}


export declare interface DemoSignetSelect extends Components.DemoSignetSelect {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'demo-signet-select',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class DemoSignetSelect {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetAccordion extends Components.SignetAccordion {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['size']
})
@Component({
  selector: 'signet-accordion',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['size']
})
export class SignetAccordion {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetAccordionSlide extends Components.SignetAccordionSlide {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['borderless', 'childTrailingLine', 'completed', 'expanded', 'heading', 'htmlContent', 'isChild', 'parentTrailingLine', 'pending', 'subHeadingHtmlContent'],
  methods: ['toggleSlide']
})
@Component({
  selector: 'signet-accordion-slide',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['borderless', 'childTrailingLine', 'completed', 'expanded', 'heading', 'htmlContent', 'isChild', 'parentTrailingLine', 'pending', 'subHeadingHtmlContent']
})
export class SignetAccordionSlide {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetAlert extends Components.SignetAlert {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['severity']
})
@Component({
  selector: 'signet-alert',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['severity']
})
export class SignetAlert {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetAvatar extends Components.SignetAvatar {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['image', 'name', 'size']
})
@Component({
  selector: 'signet-avatar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['image', 'name', 'size']
})
export class SignetAvatar {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetBreadcrumb extends Components.SignetBreadcrumb {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['items']
})
@Component({
  selector: 'signet-breadcrumb',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['items']
})
export class SignetBreadcrumb {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetButton extends Components.SignetButton {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['buttonClass', 'class', 'controls', 'disabled', 'expanded', 'haspopup', 'hides', 'shows', 'type']
})
@Component({
  selector: 'signet-button',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['buttonClass', 'class', 'controls', 'disabled', 'expanded', 'haspopup', 'hides', 'shows', 'type']
})
export class SignetButton {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetButtonGroup extends Components.SignetButtonGroup {
  /**
   * An event emitted when the value of the button group changes. 
   */
  valueChange: EventEmitter<CustomEvent<string>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['value']
})
@Component({
  selector: 'signet-button-group',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['value']
})
export class SignetButtonGroup {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


export declare interface SignetCard extends Components.SignetCard {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-card',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetCard {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}

import type { IFormFieldData as ISignetCheckboxIFormFieldData } from '@episource/signet';
export declare interface SignetCheckbox extends Components.SignetCheckbox {
  /**
   *  
   */
  changed: EventEmitter<CustomEvent<ISignetCheckboxIFormFieldData>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['checked', 'disabled', 'label', 'name', 'required', 'requiredText', 'value'],
  methods: ['validate']
})
@Component({
  selector: 'signet-checkbox',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['checked', 'disabled', 'label', 'name', 'required', 'requiredText', 'value']
})
export class SignetCheckbox {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['changed']);
  }
}


export declare interface SignetCheckmarkForm extends Components.SignetCheckmarkForm {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-checkmark-form',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetCheckmarkForm {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetChip extends Components.SignetChip {
  /**
   *  
   */
  signet-chip-close: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['chipId', 'closeable', 'image', 'label', 'variant']
})
@Component({
  selector: 'signet-chip',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['chipId', 'closeable', 'image', 'label', 'variant']
})
export class SignetChip {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['signet-chip-close']);
  }
}


export declare interface SignetCircularDataWidget extends Components.SignetCircularDataWidget {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['buttonText', 'cardDescription', 'cardTitle', 'progress', 'progressIcon', 'progressLowerText', 'progressUpperText']
})
@Component({
  selector: 'signet-circular-data-widget',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['buttonText', 'cardDescription', 'cardTitle', 'progress', 'progressIcon', 'progressLowerText', 'progressUpperText']
})
export class SignetCircularDataWidget {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetCircularLoader extends Components.SignetCircularLoader {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['size']
})
@Component({
  selector: 'signet-circular-loader',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['size']
})
export class SignetCircularLoader {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetCircularProgressBar extends Components.SignetCircularProgressBar {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['icon', 'lowerText', 'progress', 'upperText']
})
@Component({
  selector: 'signet-circular-progress-bar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['icon', 'lowerText', 'progress', 'upperText']
})
export class SignetCircularProgressBar {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetDatagrid extends Components.SignetDatagrid {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['columns', 'dataSource', 'grid_id']
})
@Component({
  selector: 'signet-datagrid',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['columns', 'dataSource', 'grid_id']
})
export class SignetDatagrid {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetDatePicker extends Components.SignetDatePicker {
  /**
   * An event emitter that fires when an invalid date is entered.
It emits an error object containing details about the invalid input. 
   */
  dateError: EventEmitter<CustomEvent<{ message: string; invalidDate: string; field: "date"; timestamp: Date; }>>;
  /**
   * An event emitter that fires when the selected date changes 
   */
  dateChange: EventEmitter<CustomEvent<string>>;
  /**
   * This event is emitted when the input element of the date picker loses focus. It can be used to perform actions or handle events when the date picker is no longer in focus. 
   */
  handleBlur: EventEmitter<CustomEvent<FocusEvent>>;
  /**
   * This event is emitted when the input element of the date picker gains focus. It can be used to perform actions or handle events when the date picker is focused, such as showing a calendar or changing the input format. 
   */
  handleFocus: EventEmitter<CustomEvent<FocusEvent>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['clearable', 'date', 'defaultValue', 'disabled', 'dummyDate', 'error', 'label', 'locale', 'maxDate', 'minDate', 'warning']
})
@Component({
  selector: 'signet-date-picker',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['clearable', 'date', 'defaultValue', 'disabled', 'dummyDate', 'error', 'label', 'locale', 'maxDate', 'minDate', 'warning']
})
export class SignetDatePicker {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['dateError', 'dateChange', 'handleBlur', 'handleFocus']);
  }
}


export declare interface SignetDateRange extends Components.SignetDateRange {
  /**
   * An event emitter that fires when the selected start or end date changes. It emits an object containing the startDate and endDate values 
   */
  changeEvent: EventEmitter<CustomEvent<{ startDate: string; endDate: string; }>>;
  /**
   * An event emitter that fires when the date range picker loses focus. 
   */
  handleBlur: EventEmitter<CustomEvent<FocusEvent>>;
  /**
   * This event is emitted when the input element of the date picker gains focus. It can be used to perform actions or handle events when the date picker is focused, such as showing a calendar or changing the input format. 
   */
  handleFocus: EventEmitter<CustomEvent<FocusEvent>>;
  /**
   * An event emitter that fires when an invalid date is entered.
It emits an error object containing details about the invalid input. 
   */
  dateError: EventEmitter<CustomEvent<{ message: string; invalidDate: string; field: "startDate" | "endDate"; timestamp: Date; }>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['autoFillEndDate', 'clearable', 'defaultValue', 'disabled', 'dummyDate', 'endDate', 'endDateLabel', 'error', 'locale', 'maxDate', 'minDate', 'startDate', 'startDateLabel', 'warning']
})
@Component({
  selector: 'signet-date-range',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['autoFillEndDate', 'clearable', 'defaultValue', 'disabled', 'dummyDate', 'endDate', 'endDateLabel', 'error', 'locale', 'maxDate', 'minDate', 'startDate', 'startDateLabel', 'warning']
})
export class SignetDateRange {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['changeEvent', 'handleBlur', 'handleFocus', 'dateError']);
  }
}


export declare interface SignetDateRangeAdvanced extends Components.SignetDateRangeAdvanced {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-date-range-advanced',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetDateRangeAdvanced {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetDialog extends Components.SignetDialog {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['dialogTitle', 'size'],
  methods: ['show', 'hide']
})
@Component({
  selector: 'signet-dialog',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['dialogTitle', 'size']
})
export class SignetDialog {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetDivider extends Components.SignetDivider {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['vertical']
})
@Component({
  selector: 'signet-divider',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['vertical']
})
export class SignetDivider {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetDrawer extends Components.SignetDrawer {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['headerText', 'openDrawer', 'position', 'size'],
  methods: ['hide', 'show']
})
@Component({
  selector: 'signet-drawer',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['headerText', 'openDrawer', 'position', 'size']
})
export class SignetDrawer {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetH1 extends Components.SignetH1 {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-h1',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetH1 {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetH2 extends Components.SignetH2 {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-h2',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetH2 {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetH3 extends Components.SignetH3 {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-h3',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetH3 {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetH4 extends Components.SignetH4 {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-h4',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetH4 {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetH5 extends Components.SignetH5 {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-h5',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetH5 {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetH6 extends Components.SignetH6 {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-h6',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetH6 {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetHeader extends Components.SignetHeader {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['fixed', 'logo']
})
@Component({
  selector: 'signet-header',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['fixed', 'logo']
})
export class SignetHeader {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetHeaderGroup extends Components.SignetHeaderGroup {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['position']
})
@Component({
  selector: 'signet-header-group',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['position']
})
export class SignetHeaderGroup {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetHeaderItem extends Components.SignetHeaderItem {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-header-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetHeaderItem {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetHeaderRow extends Components.SignetHeaderRow {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-header-row',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetHeaderRow {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetIcon extends Components.SignetIcon {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['icon', 'name', 'variant']
})
@Component({
  selector: 'signet-icon',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['icon', 'name', 'variant']
})
export class SignetIcon {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetIconOnly extends Components.SignetIconOnly {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['icon', 'notificationCount']
})
@Component({
  selector: 'signet-icon-only',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['icon', 'notificationCount']
})
export class SignetIconOnly {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetInput extends Components.SignetInput {
  /**
   * Emitted when a keyboard input occurred. 
   */
  signet:input: EventEmitter<CustomEvent<any>>;
  /**
   * Emitted when the value has changed. 
   */
  signet:change: EventEmitter<CustomEvent<any>>;
  /**
   * Emitted when the input loses focus. 
   */
  signet:blur: EventEmitter<CustomEvent<any>>;
  /**
   * Emitted when the input has focus. 
   */
  signet:focus: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['autocomplete', 'buttonText', 'clearable', 'configAria', 'debounce', 'disabled', 'hasButton', 'label', 'modelValue', 'name', 'placeholder', 'readonly', 'required', 'size', 'state', 'type', 'value'],
  methods: ['getComponentId', 'setFocus', 'setBlur']
})
@Component({
  selector: 'signet-input',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['autocomplete', 'buttonText', 'clearable', 'configAria', 'debounce', 'disabled', 'hasButton', 'label', 'modelValue', 'name', 'placeholder', 'readonly', 'required', 'size', 'state', 'type', 'value']
})
export class SignetInput {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['signet:input', 'signet:change', 'signet:blur', 'signet:focus']);
  }
}


export declare interface SignetLinearLoader extends Components.SignetLinearLoader {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['isDeterminate']
})
@Component({
  selector: 'signet-linear-loader',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['isDeterminate']
})
export class SignetLinearLoader {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetList extends Components.SignetList {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-list',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetList {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetListItem extends Components.SignetListItem {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-list-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetListItem {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogo extends Components.SignetLogo {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['name']
})
@Component({
  selector: 'signet-logo',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['name']
})
export class SignetLogo {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoAdaptiveCoder extends Components.SignetLogoAdaptiveCoder {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-adaptive-coder',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoAdaptiveCoder {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoAnalyst extends Components.SignetLogoAnalyst {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-analyst',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoAnalyst {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoCoder extends Components.SignetLogoCoder {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-coder',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoCoder {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoConnect extends Components.SignetLogoConnect {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-connect',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoConnect {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoEpisource extends Components.SignetLogoEpisource {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-episource',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoEpisource {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoHub extends Components.SignetLogoHub {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-hub',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoHub {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoPortal extends Components.SignetLogoPortal {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-portal',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoPortal {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoSignet extends Components.SignetLogoSignet {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-signet',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoSignet {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetLogoSubmitter extends Components.SignetLogoSubmitter {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['alt', 'href', 'src']
})
@Component({
  selector: 'signet-logo-submitter',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['alt', 'href', 'src']
})
export class SignetLogoSubmitter {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetMenu extends Components.SignetMenu {
  /**
   *  
   */
  shown: EventEmitter<CustomEvent<any>>;
  /**
   *  
   */
  hidden: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['collapse', 'disabled', 'display', 'harmony', 'helperText', 'hideIndicator', 'hideText', 'icon', 'loading', 'megaMenu', 'modelValue', 'position', 'size', 'text', 'variant'],
  methods: ['hide', 'show']
})
@Component({
  selector: 'signet-menu',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['collapse', 'disabled', 'display', 'harmony', 'helperText', 'hideIndicator', 'hideText', 'icon', 'loading', 'megaMenu', 'modelValue', 'position', 'size', 'text', 'variant']
})
export class SignetMenu {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['shown', 'hidden']);
  }
}


export declare interface SignetMenuItem extends Components.SignetMenuItem {
  /**
   *  
   */
  closeMenu: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['preventClose']
})
@Component({
  selector: 'signet-menu-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['preventClose']
})
export class SignetMenuItem {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['closeMenu']);
  }
}


export declare interface SignetModal extends Components.SignetModal {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['modalTitle', 'openModal', 'preventClose', 'size'],
  methods: ['show', 'hide']
})
@Component({
  selector: 'signet-modal',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['modalTitle', 'openModal', 'preventClose', 'size']
})
export class SignetModal {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetMonthYearPicker extends Components.SignetMonthYearPicker {
  /**
   *  
   */
  inputChange: EventEmitter<CustomEvent<string>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['value']
})
@Component({
  selector: 'signet-month-year-picker',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['value']
})
export class SignetMonthYearPicker {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['inputChange']);
  }
}


export declare interface SignetOption extends Components.SignetOption {
  /**
   *  
   */
  optionSelected: EventEmitter<CustomEvent<string>>;
  /**
   *  
   */
  optionLabel: EventEmitter<CustomEvent<string>>;
  /**
   *  
   */
  closeSelect: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['label', 'value']
})
@Component({
  selector: 'signet-option',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['label', 'value']
})
export class SignetOption {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['optionSelected', 'optionLabel', 'closeSelect']);
  }
}


export declare interface SignetOverlay extends Components.SignetOverlay {
  /**
   *  
   */
  shown: EventEmitter<CustomEvent<any>>;
  /**
   *  
   */
  hidden: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['absolute', 'openModal', 'preventClose', 'titleId'],
  methods: ['show', 'hide']
})
@Component({
  selector: 'signet-overlay',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['absolute', 'openModal', 'preventClose', 'titleId']
})
export class SignetOverlay {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['shown', 'hidden']);
  }
}


export declare interface SignetPagination extends Components.SignetPagination {
  /**
   *  
   */
  pageChange: EventEmitter<CustomEvent<number>>;
  /**
   *  
   */
  pageSizeChange: EventEmitter<CustomEvent<number>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['currentPage', 'pageSize', 'pageSizeOptions', 'totalItems', 'totalPages']
})
@Component({
  selector: 'signet-pagination',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['currentPage', 'pageSize', 'pageSizeOptions', 'totalItems', 'totalPages']
})
export class SignetPagination {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['pageChange', 'pageSizeChange']);
  }
}


export declare interface SignetPdfPagination extends Components.SignetPdfPagination {
  /**
   *  
   */
  nextClick: EventEmitter<CustomEvent<void>>;
  /**
   *  
   */
  previousClick: EventEmitter<CustomEvent<void>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['label']
})
@Component({
  selector: 'signet-pdf-pagination',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['label']
})
export class SignetPdfPagination {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['nextClick', 'previousClick']);
  }
}


export declare interface SignetPdfViewer extends Components.SignetPdfViewer {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['image', 'imagePreview', 'pdfTitle', 'severity']
})
@Component({
  selector: 'signet-pdf-viewer',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['image', 'imagePreview', 'pdfTitle', 'severity']
})
export class SignetPdfViewer {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetPopover extends Components.SignetPopover {
  /**
   *  
   */
  shown: EventEmitter<CustomEvent<any>>;
  /**
   *  
   */
  hidden: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['buttonText', 'collapse', 'disabled', 'display', 'hideText', 'loading', 'size'],
  methods: ['hide', 'show']
})
@Component({
  selector: 'signet-popover',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['buttonText', 'collapse', 'disabled', 'display', 'hideText', 'loading', 'size']
})
export class SignetPopover {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['shown', 'hidden']);
  }
}


export declare interface SignetProgress extends Components.SignetProgress {}

@ProxyCmp({
  defineCustomElementFn: undefined
})
@Component({
  selector: 'signet-progress',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>'
})
export class SignetProgress {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetProgressStep extends Components.SignetProgressStep {
  /**
   *  
   */
  stepClicked: EventEmitter<CustomEvent<void>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['complete', 'disabled', 'inProgress', 'invalid', 'label']
})
@Component({
  selector: 'signet-progress-step',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['complete', 'disabled', 'inProgress', 'invalid', 'label']
})
export class SignetProgressStep {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['stepClicked']);
  }
}


export declare interface SignetRadio extends Components.SignetRadio {
  /**
   *  
   */
  selected: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['checked', 'disabled', 'inline', 'label', 'name', 'value']
})
@Component({
  selector: 'signet-radio',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['checked', 'disabled', 'inline', 'label', 'name', 'value']
})
export class SignetRadio {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['selected']);
  }
}


export declare interface SignetScrollingMenu extends Components.SignetScrollingMenu {}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['modelValue', 'sectionContents', 'sections', 'titles']
})
@Component({
  selector: 'signet-scrolling-menu',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['modelValue', 'sectionContents', 'sections', 'titles']
})
export class SignetScrollingMenu {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SignetSelect extends Components.SignetSelect {
  /**
   * The `hidden` event is emitted when the select component is hidden.
It can be used to trigger actions or updates in other parts of the application when the dropdown menu is closed. 
   */
  hidden: EventEmitter<CustomEvent<any>>;
  /**
   * The `shown` event is emitted when the select component is shown.
It can be used to trigger actions or updates in other parts of the application when the dropdown menu is opened. 
   */
  shown: EventEmitter<CustomEvent<any>>;
  /**
   * The `selectedValue` event is emitted when an option is selected from the dropdown menu.
It can be used to trigger actions or updates in other parts of the application based on the selected value. 
   */
  selectedValue: EventEmitter<CustomEvent<string | string[]>>;
  /**
   * The `optionSelected` event is emitted when an option is selected from the dropdown menu.
It can be used to trigger actions or updates in other parts of the application based on the selected option. 
   */
  optionSelected: EventEmitter<CustomEvent<string | string[]>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['defaultValue', 'disabled', 'hasOnlySearch', 'hasSearch', 'instanceKey', 'items', 'label', 'labelField', 'loadItems', 'modelValue', 'multiple', 'options', 'placeholder', 'readonly', 'searchPlaceholder', 'size', 'src', 'valueField'],
  methods: ['hide', 'show']
})
@Component({
  selector: 'signet-select',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['defaultValue', 'disabled', 'hasOnlySearch', 'hasSearch', 'instanceKey', 'items', 'label', 'labelField', 'loadItems', 'modelValue', 'multiple', 'options', 'placeholder', 'readonly', 'searchPlaceholder', 'size', 'src', 'valueField']
})
export class SignetSelect {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['hidden', 'shown', 'selectedValue', 'optionSelected']);
  }
}


export declare interface SignetSelectAlt extends Components.SignetSelectAlt {
  /**
   *  
   */
  signet:change: EventEmitter<CustomEvent<any>>;

}

@ProxyCmp({
  defineCustomElementFn: undefined,
  inputs: ['disabled', 'isClearable', 'isMulti', 'isSearchable', 'label', 'options', 'placeholder', 'value']
})
@Component({
  selector: 'signet-select-alt',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  inputs: ['disabled', 'isClearable', 'isMulti', 'isSearchable', 'label', 'options', 'placeholder', 'v