gov-gui/angular/src/directives/proxies.ts

Gov UI Component Library Typscript Build

/* 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 'gov-gui';


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'openIndex']
})
@Component({
  selector: 'gov-accordion',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'openIndex'],
})
export class GovAccordion {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovAccordion extends Components.GovAccordion {}


@ProxyCmp({
  inputs: ['label']
})
@Component({
  selector: 'gov-accordion-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label'],
})
export class GovAccordionItem {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovAccordionItem extends Components.GovAccordionItem {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'header', 'icon', 'label', 'showIcons', 'variant']
})
@Component({
  selector: 'gov-alert',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'header', 'icon', 'label', 'showIcons', 'variant'],
})
export class GovAlert {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovAlert extends Components.GovAlert {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'hasNotification', 'imgUrl', 'initials', 'notificationCount', 'size', 'status']
})
@Component({
  selector: 'gov-avatar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'hasNotification', 'imgUrl', 'initials', 'notificationCount', 'size', 'status'],
})
export class GovAvatar {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovAvatar extends Components.GovAvatar {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'classes', 'size', 'styles', 'variant']
})
@Component({
  selector: 'gov-badge',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'classes', 'size', 'styles', 'variant'],
})
export class GovBadge {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovBadge extends Components.GovBadge {}


@ProxyCmp({
  inputs: ['align', 'auto', 'classes', 'gap', 'isFlexBox', 'justify', 'lg', 'md', 'size', 'sm', 'styles', 'xl', 'xs']
})
@Component({
  selector: 'gov-box',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['align', 'auto', 'classes', 'gap', 'isFlexBox', 'justify', 'lg', 'md', 'size', 'sm', 'styles', 'xl', 'xs'],
})
export class GovBox {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovBox extends Components.GovBox {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed']
})
@Component({
  selector: 'gov-breadcrumb',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed'],
})
export class GovBreadcrumb {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovBreadcrumb extends Components.GovBreadcrumb {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'clicked', 'disabled', 'hasPrefix', 'hasSuffix', 'icon', 'iconSize', 'label', 'size', 'type', 'typeVariant', 'variant']
})
@Component({
  selector: 'gov-button',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'clicked', 'disabled', 'hasPrefix', 'hasSuffix', 'icon', 'iconSize', 'label', 'size', 'type', 'typeVariant', 'variant'],
})
export class GovButton {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovButton extends Components.GovButton {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'date', 'required'],
  methods: ['validate']
})
@Component({
  selector: 'gov-calender',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'date', 'required'],
})
export class GovCalender {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovCalender extends Components.GovCalender {}


@ProxyCmp({
  inputs: ['alignment', 'animation', 'animationDelay', 'animationSpeed', 'buttonText', 'cardTitle', 'description', 'imageClip', 'imageSrc', 'showButton']
})
@Component({
  selector: 'gov-card',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['alignment', 'animation', 'animationDelay', 'animationSpeed', 'buttonText', 'cardTitle', 'description', 'imageClip', 'imageSrc', 'showButton'],
})
export class GovCard {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['cardButtonClicked']);
  }
}


export declare interface GovCard extends Components.GovCard {

  cardButtonClicked: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'data', 'options', 'type']
})
@Component({
  selector: 'gov-chart',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'data', 'options', 'type'],
})
export class GovChart {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovChart extends Components.GovChart {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'checked', 'disabled', 'label', 'required', 'requiredErrorMessage', 'value'],
  methods: ['getValue', 'validate']
})
@Component({
  selector: 'gov-checkbox',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'checked', 'disabled', 'label', 'required', 'requiredErrorMessage', 'value'],
})
export class GovCheckbox {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChanged']);
  }
}


export declare interface GovCheckbox extends Components.GovCheckbox {

  valueChanged: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'disabled', 'label', 'selected', 'size', 'variant']
})
@Component({
  selector: 'gov-chip',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'disabled', 'label', 'selected', 'size', 'variant'],
})
export class GovChip {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovChip extends Components.GovChip {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'name']
})
@Component({
  selector: 'gov-choice-chips',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'name'],
})
export class GovChoiceChips {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovChoiceChips extends Components.GovChoiceChips {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'description', 'label', 'options']
})
@Component({
  selector: 'gov-combo-box',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'description', 'label', 'options'],
})
export class GovComboBox {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovComboBox extends Components.GovComboBox {}


@ProxyCmp({
  inputs: ['fluid', 'size']
})
@Component({
  selector: 'gov-container',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['fluid', 'size'],
})
export class GovContainer {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovContainer extends Components.GovContainer {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'date', 'required', 'time'],
  methods: ['validate']
})
@Component({
  selector: 'gov-date-time-picker',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'date', 'required', 'time'],
})
export class GovDateTimePicker {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['selectedDateEvent', 'selectedTimeEvent']);
  }
}


export declare interface GovDateTimePicker extends Components.GovDateTimePicker {

  selectedDateEvent: EventEmitter<CustomEvent<string>>;

  selectedTimeEvent: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'heading', 'options', 'subtitle']
})
@Component({
  selector: 'gov-drop',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'heading', 'options', 'subtitle'],
})
export class GovDrop {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovDrop extends Components.GovDrop {}


@ProxyCmp({
  inputs: ['options', 'selected']
})
@Component({
  selector: 'gov-dropdown',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['options', 'selected'],
})
export class GovDropdown {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChanged']);
  }
}


export declare interface GovDropdown extends Components.GovDropdown {

  valueChanged: EventEmitter<CustomEvent<number>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'cancelBtnText', 'encType', 'header', 'hideCancelBtn', 'hideSubmitBtn', 'method', 'resetOnSubmit', 'submitBtnText', 'url', 'variant']
})
@Component({
  selector: 'gov-form',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'cancelBtnText', 'encType', 'header', 'hideCancelBtn', 'hideSubmitBtn', 'method', 'resetOnSubmit', 'submitBtnText', 'url', 'variant'],
})
export class GovForm {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['formSubmitted']);
  }
}


export declare interface GovForm extends Components.GovForm {

  formSubmitted: EventEmitter<CustomEvent<Record<string, string>>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'color', 'name', 'size', 'variant']
})
@Component({
  selector: 'gov-icon',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'color', 'name', 'size', 'variant'],
})
export class GovIcon {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovIcon extends Components.GovIcon {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'disabled', 'errorMessage', 'icon', 'label', 'legend', 'maxlength', 'placeholder', 'required', 'requiredErrorMessage', 'type', 'validationPattern', 'value'],
  methods: ['getValue', 'validate']
})
@Component({
  selector: 'gov-input',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'disabled', 'errorMessage', 'icon', 'label', 'legend', 'maxlength', 'placeholder', 'required', 'requiredErrorMessage', 'type', 'validationPattern', 'value'],
})
export class GovInput {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChanged', 'validationChanged']);
  }
}


export declare interface GovInput extends Components.GovInput {

  valueChanged: EventEmitter<CustomEvent<string>>;

  validationChanged: EventEmitter<CustomEvent<boolean>>;
}


@ProxyCmp({
  inputs: ['avatarImgUrl', 'avatarInitials', 'menuType', 'showSideBarAvatar', 'showTopBarAvatar', 'sidebarItems', 'sidebarUsername', 'topBarItems', 'topBarUsername']
})
@Component({
  selector: 'gov-layout',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['avatarImgUrl', 'avatarInitials', 'menuType', 'showSideBarAvatar', 'showTopBarAvatar', 'sidebarItems', 'sidebarUsername', 'topBarItems', 'topBarUsername'],
})
export class GovLayout {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovLayout extends Components.GovLayout {}


@ProxyCmp({
  inputs: ['sidebar', 'topbar']
})
@Component({
  selector: 'gov-layout-old',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['sidebar', 'topbar'],
})
export class GovLayoutOld {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovLayoutOld extends Components.GovLayoutOld {}


@ProxyCmp({
  inputs: ['alignment', 'animation', 'animationDelay', 'animationSpeed', 'items']
})
@Component({
  selector: 'gov-list',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['alignment', 'animation', 'animationDelay', 'animationSpeed', 'items'],
})
export class GovList {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['selectedItem']);
  }
}


export declare interface GovList extends Components.GovList {

  selectedItem: EventEmitter<CustomEvent<number>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'items', 'type']
})
@Component({
  selector: 'gov-menubar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'items', 'type'],
})
export class GovMenubar {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovMenubar extends Components.GovMenubar {}


@ProxyCmp({
  inputs: ['Subheader', 'animation', 'animationDelay', 'animationSpeed', 'backdropClose', 'cancelButtonText', 'cancelButtonVariant', 'closeOnEsc', 'confirmButtonText', 'confirmButtonVariant', 'disableClose', 'fullscreen', 'header', 'isOpen', 'showCancelButton', 'showConfirmButton', 'showFooter', 'showHeader', 'showSubHeader', 'size'],
  methods: ['open', 'close']
})
@Component({
  selector: 'gov-modal',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['Subheader', 'animation', 'animationDelay', 'animationSpeed', 'backdropClose', 'cancelButtonText', 'cancelButtonVariant', 'closeOnEsc', 'confirmButtonText', 'confirmButtonVariant', 'disableClose', 'fullscreen', 'header', 'isOpen', 'showCancelButton', 'showConfirmButton', 'showFooter', 'showHeader', 'showSubHeader', 'size'],
})
export class GovModal {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['opened', 'closed', 'confirm', 'cancel', 'isOpenChange']);
  }
}


export declare interface GovModal extends Components.GovModal {
  /**
   * Emitted when modal opens
   */
  opened: EventEmitter<CustomEvent<void>>;
  /**
   * Emitted when modal closes
   */
  closed: EventEmitter<CustomEvent<void>>;
  /**
   * Emitted on confirm button click
   */
  confirm: EventEmitter<CustomEvent<void>>;
  /**
   * Emitted on cancel button click
   */
  cancel: EventEmitter<CustomEvent<void>>;
  /**
   * Emitted for two-way binding
   */
  isOpenChange: EventEmitter<CustomEvent<boolean>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'currentPage', 'maxVisible', 'showFirstLast', 'totalPages']
})
@Component({
  selector: 'gov-pagination',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'currentPage', 'maxVisible', 'showFirstLast', 'totalPages'],
})
export class GovPagination {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['pageChanged']);
  }
}


export declare interface GovPagination extends Components.GovPagination {

  pageChanged: EventEmitter<CustomEvent<number>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'backdropClose', 'cancelButtonText', 'cancelButtonVariant', 'confirmButtonText', 'confirmButtonVariant', 'disableClose', 'header', 'showCancelButton', 'showConfirmButton', 'subheader'],
  methods: ['openModal', 'closeModal']
})
@Component({
  selector: 'gov-popups',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'backdropClose', 'cancelButtonText', 'cancelButtonVariant', 'confirmButtonText', 'confirmButtonVariant', 'disableClose', 'header', 'showCancelButton', 'showConfirmButton', 'subheader'],
})
export class GovPopups {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['popupOpened', 'popupClosed', 'confirmClicked', 'cancelClicked']);
  }
}


export declare interface GovPopups extends Components.GovPopups {
  /**
   * Emits when the modal opens
   */
  popupOpened: EventEmitter<CustomEvent<void>>;
  /**
   * Emits when the modal closes
   */
  popupClosed: EventEmitter<CustomEvent<void>>;
  /**
   * Emits when the confirm button is clicked
   */
  confirmClicked: EventEmitter<CustomEvent<void>>;
  /**
   * Emits when the cancel button is clicked
   */
  cancelClicked: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'label', 'progress', 'type', 'variant']
})
@Component({
  selector: 'gov-progress-bar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'label', 'progress', 'type', 'variant'],
})
export class GovProgressBar {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovProgressBar extends Components.GovProgressBar {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'heading', 'name', 'options', 'required', 'requiredErrorMessage', 'subtitle', 'value'],
  methods: ['validate']
})
@Component({
  selector: 'gov-radiobutton',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'heading', 'name', 'options', 'required', 'requiredErrorMessage', 'subtitle', 'value'],
})
export class GovRadiobutton {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['selectedChange']);
  }
}


export declare interface GovRadiobutton extends Components.GovRadiobutton {

  selectedChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['align', 'classes', 'gap', 'justify', 'reverse', 'styles']
})
@Component({
  selector: 'gov-row',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['align', 'classes', 'gap', 'justify', 'reverse', 'styles'],
})
export class GovRow {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovRow extends Components.GovRow {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'name', 'variant']
})
@Component({
  selector: 'gov-segmented-chips',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'name', 'variant'],
})
export class GovSegmentedChips {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovSegmentedChips extends Components.GovSegmentedChips {}


@ProxyCmp({
  inputs: ['avatarImgUrl', 'avatarInitials', 'items', 'showSideBarAvatar', 'sidebarUsername']
})
@Component({
  selector: 'gov-sidebar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['avatarImgUrl', 'avatarInitials', 'items', 'showSideBarAvatar', 'sidebarUsername'],
})
export class GovSidebar {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovSidebar extends Components.GovSidebar {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'label', 'max', 'min', 'step', 'value']
})
@Component({
  selector: 'gov-slider',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'label', 'max', 'min', 'step', 'value'],
})
export class GovSlider {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['sliderChange']);
  }
}


export declare interface GovSlider extends Components.GovSlider {

  sliderChange: EventEmitter<CustomEvent<number>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'maxStepsVisible', 'nextText', 'onSubmit', 'prevText', 'resetOnSubmit', 'submitText', 'validateStep', 'variant']
})
@Component({
  selector: 'gov-stepper',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'maxStepsVisible', 'nextText', 'onSubmit', 'prevText', 'resetOnSubmit', 'submitText', 'validateStep', 'variant'],
})
export class GovStepper {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['stepChanged', 'stepSubmitted', 'stepError']);
  }
}


export declare interface GovStepper extends Components.GovStepper {

  stepChanged: EventEmitter<CustomEvent<number>>;

  stepSubmitted: EventEmitter<CustomEvent<Record<string, string>>>;

  stepError: EventEmitter<CustomEvent<Error>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'disabled', 'hasIcons', 'isOn', 'showLabel', 'size']
})
@Component({
  selector: 'gov-switcher',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'disabled', 'hasIcons', 'isOn', 'showLabel', 'size'],
})
export class GovSwitcher {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['toggled']);
  }
}


export declare interface GovSwitcher extends Components.GovSwitcher {

  toggled: EventEmitter<CustomEvent<boolean>>;
}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'data', 'headings', 'rowActions', 'rowsPerPage']
})
@Component({
  selector: 'gov-table',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'data', 'headings', 'rowActions', 'rowsPerPage'],
})
export class GovTable {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['rowActionClicked']);
  }
}


export declare interface GovTable extends Components.GovTable {
  /**
   * Event emitted when a row action button is clicked.
The event detail includes the action identifier, the row data and the row index.
   */
  rowActionClicked: EventEmitter<CustomEvent<{ action: string; row: string[]; rowIndex: number }>>;
}


@ProxyCmp({
  inputs: ['activeTab', 'animation', 'animationDelay', 'animationSpeed', 'disabledTabs', 'tabList']
})
@Component({
  selector: 'gov-tabs',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['activeTab', 'animation', 'animationDelay', 'animationSpeed', 'disabledTabs', 'tabList'],
})
export class GovTabs {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovTabs extends Components.GovTabs {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'duration', 'icon', 'message', 'variant'],
  methods: ['show']
})
@Component({
  selector: 'gov-toaster',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'duration', 'icon', 'message', 'variant'],
})
export class GovToaster {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovToaster extends Components.GovToaster {}


@ProxyCmp({
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'color', 'hoverDelay', 'position', 'size', 'text']
})
@Component({
  selector: 'gov-tooltip',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'animationDelay', 'animationSpeed', 'color', 'hoverDelay', 'position', 'size', 'text'],
})
export class GovTooltip {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovTooltip extends Components.GovTooltip {}


@ProxyCmp({
  inputs: ['avatarImgUrl', 'avatarInitials', 'menuType', 'showTopBarAvatar', 'siteMenuItems', 'topBarUsername']
})
@Component({
  selector: 'gov-topbar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['avatarImgUrl', 'avatarInitials', 'menuType', 'showTopBarAvatar', 'siteMenuItems', 'topBarUsername'],
})
export class GovTopbar {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovTopbar extends Components.GovTopbar {}


@ProxyCmp({
  inputs: ['allowedFileTypes', 'animation', 'animationDelay', 'animationSpeed', 'fileNameValue', 'required'],
  methods: ['setUploadUrl', 'validate']
})
@Component({
  selector: 'gov-upload',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['allowedFileTypes', 'animation', 'animationDelay', 'animationSpeed', 'fileNameValue', 'required'],
})
export class GovUpload {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface GovUpload extends Components.GovUpload {}


@ProxyCmp({
  inputs: ['first', 'last', 'middle']
})
@Component({
  selector: 'my-component',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['first', 'last', 'middle'],
})
export class MyComponent {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface MyComponent extends Components.MyComponent {}


@ProxyCmp({
})
@Component({
  selector: 'page-sample',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [],
})
export class PageSample {
  protected el: HTMLElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface PageSample extends Components.PageSample {}